@andersbakken/fisk 4.0.55 → 4.0.57

package/daemon/fisk-daemon.js

@@ -42,6 +42,12 @@ const Constants = {
     get JSON() {
         return 5;
     },
+    get AcquireSlot() {
+        return 6;
+    },
+    get ReleaseLocalSlot() {
+        return 7;
+    },
     // daemon codes
     get CppSlotAcquired() {
         return 10;
@@ -51,6 +57,9 @@ const Constants = {
     },
     get JSONResponse() {
         return 12;
+    },
+    get LocalSlotAcquired() {
+        return 13;
     }
 };
 
@@ -208,6 +217,12 @@ class Compile extends EventEmitter__default["default"] {
                     case Constants.ReleaseCompileSlot:
                         emit("releaseCompileSlot");
                         continue;
+                    case Constants.AcquireSlot:
+                        emit("acquireSlot");
+                        continue;
+                    case Constants.ReleaseLocalSlot:
+                        emit("releaseLocalSlot");
+                        continue;
                     case Constants.JSON:
                         if (available < 5) {
                             break;
@@ -3330,16 +3345,40 @@ class Slots extends EventEmitter__default["default"] {
         this.debug = debug;
         this.used = new Map();
         this.pending = new Map();
+        this._totalAcquired = 0;
         if (this.debug) {
             console.log("Slots created", this.toString());
         }
     }
+    get capacity() {
+        return this.count;
+    }
+    get active() {
+        return this.used.size;
+    }
+    get totalAcquired() {
+        return this._totalAcquired;
+    }
+    tryAcquire(id, data) {
+        if (this.used.size < this.count) {
+            this.used.set(id, data);
+            ++this._totalAcquired;
+            if (this.debug) {
+                console.log("tryAcquire succeeded", id, data, this.toString());
+            }
+            this.emit("changed");
+            return true;
+        }
+        return false;
+    }
     acquire(id, data, cb) {
         if (this.used.size < this.count) {
             this.used.set(id, data);
+            ++this._totalAcquired;
             if (this.debug) {
                 console.log("acquired slot", id, data, this.toString());
             }
+            this.emit("changed");
             cb();
         }
         else {
@@ -3363,9 +3402,11 @@ class Slots extends EventEmitter__default["default"] {
             for (const p of this.pending) {
                 this.used.set(p[0], p[1].data);
                 this.pending.delete(p[0]);
+                ++this._totalAcquired;
                 p[1].cb();
                 break;
             }
+            this.emit("changed");
         }
     }
     toString() {
@@ -4118,6 +4159,8 @@ Options:
   --socket=PATH          Unix socket path (default: ~/.cache/fisk/daemon/socket)
   --cpp-slots=N          Preprocess slot count (default: cpus * 2)
   --slots=N              Compile slot count (default: cpus)
+  --local-slots=N        Local compile slot count (default: 0, disabled)
+  --local-slots-max-load=N  Max system load average (1-min) to allow local compiles (default: 0, no limit)
   --cache-dir=PATH       Cache directory (default: ~/.cache/fisk/daemon)
 
 Config files: ~/.config/fisk/daemon.conf, /etc/xdg/fisk/daemon.conf
@@ -4153,15 +4196,87 @@ server.on("error", (err) => {
 });
 const cppSlots = new Slots(option.int("cpp-slots", Math.max(os__default["default"].cpus().length * 2, 1)), "cpp", debug);
 const compileSlots = new Slots(option.int("slots", Math.max(os__default["default"].cpus().length, 1)), "compile", debug);
+const localSlotCount = option.int("local-slots", 0);
+const localSlots = new Slots(localSlotCount, "local", debug);
+const localSlotsMaxLoad = option("local-slots-max-load") || 0;
+const slotSubscribers = [];
+function slotsInfo() {
+    return {
+        type: "slotsInfo",
+        local: {
+            active: localSlots.active,
+            capacity: localSlots.capacity,
+            total: localSlots.totalAcquired
+        },
+        cpp: {
+            active: cppSlots.active,
+            capacity: cppSlots.capacity,
+            total: cppSlots.totalAcquired
+        },
+        compile: {
+            active: compileSlots.active,
+            capacity: compileSlots.capacity,
+            total: compileSlots.totalAcquired
+        }
+    };
+}
+function broadcastSlotsInfo() {
+    if (slotSubscribers.length === 0) {
+        return;
+    }
+    const info = slotsInfo();
+    for (const sub of slotSubscribers) {
+        sub.compile.send(info);
+    }
+}
+for (const slots of [localSlots, cppSlots, compileSlots]) {
+    slots.on("changed", broadcastSlotsInfo);
+}
+function canAcquireLocalSlot() {
+    if (localSlotCount <= 0) {
+        return false;
+    }
+    if (localSlotsMaxLoad > 0) {
+        const loadAvg = os__default["default"].loadavg()[0];
+        if (loadAvg > localSlotsMaxLoad) {
+            if (debug) {
+                console.log(`Local slot denied: load ${loadAvg.toFixed(2)} > max ${localSlotsMaxLoad}`);
+            }
+            return false;
+        }
+    }
+    return true;
+}
 server.on("compile", (compile) => {
     compile.on("dumpSlots", () => {
-        const ret = { cpp: cppSlots.dump(), compile: compileSlots.dump() };
+        const ret = { cpp: cppSlots.dump(), compile: compileSlots.dump(), local: localSlots.dump() };
         if (debug) {
             console.log("sending dump", ret);
         }
         compile.send(ret);
     });
+    compile.on("subscribeSlots", () => {
+        if (debug) {
+            console.log("subscribeSlots from", compile.id);
+        }
+        const subscriber = {
+            compile,
+            handler: () => {
+                // Remove subscriber on disconnect
+                const idx = slotSubscribers.indexOf(subscriber);
+                if (idx !== -1) {
+                    slotSubscribers.splice(idx, 1);
+                }
+            }
+        };
+        slotSubscribers.push(subscriber);
+        compile.on("end", subscriber.handler);
+        compile.on("error", subscriber.handler);
+        // Send current state immediately
+        compile.send(slotsInfo());
+    });
     let requestedCppSlot = false;
+    let requestedLocalSlot = false;
     compile.on("acquireCppSlot", () => {
         if (debug) {
             console.log("acquireCppSlot");
@@ -4205,6 +4320,38 @@ server.on("compile", (compile) => {
             compileSlots.release(compile.id);
         }
     });
+    compile.on("acquireSlot", () => {
+        if (debug) {
+            console.log("acquireSlot");
+        }
+        if (canAcquireLocalSlot() && localSlots.tryAcquire(compile.id, { pid: compile.pid })) {
+            if (debug) {
+                console.log("acquireSlot -> local slot granted");
+            }
+            requestedLocalSlot = true;
+            compile.send(Constants.LocalSlotAcquired);
+        }
+        else {
+            if (debug) {
+                console.log("acquireSlot -> falling back to cpp slot");
+            }
+            assert__default["default"](!requestedCppSlot);
+            requestedCppSlot = true;
+            cppSlots.acquire(compile.id, { pid: compile.pid }, () => {
+                compile.send(Constants.CppSlotAcquired);
+            });
+        }
+    });
+    compile.on("releaseLocalSlot", () => {
+        if (debug) {
+            console.log("releaseLocalSlot");
+        }
+        assert__default["default"](requestedLocalSlot);
+        if (requestedLocalSlot) {
+            requestedLocalSlot = false;
+            localSlots.release(compile.id);
+        }
+    });
     compile.on("error", (err) => {
         if (debug) {
             console.error("Got error from fiskc", compile.id, compile.pid, err);
@@ -4217,6 +4364,10 @@ server.on("compile", (compile) => {
             requestedCompileSlot = false;
             compileSlots.release(compile.id);
         }
+        if (requestedLocalSlot) {
+            requestedLocalSlot = false;
+            localSlots.release(compile.id);
+        }
     });
     compile.on("end", () => {
         if (debug) {
@@ -4230,6 +4381,10 @@ server.on("compile", (compile) => {
             requestedCompileSlot = false;
             compileSlots.release(compile.id);
         }
+        if (requestedLocalSlot) {
+            requestedLocalSlot = false;
+            localSlots.release(compile.id);
+        }
     });
 });
 process.on("exit", () => {

package/monitor/fisk-monitor.js

@@ -5895,6 +5895,7 @@ if (process.argv.includes("--help") || process.argv.includes("-h")) {
 
 Options:
   --scheduler=URL        Scheduler URL (default: ws://localhost:8097)
+  --daemon-socket=PATH   Daemon Unix socket path (default: ~/.cache/fisk/daemon/socket)
 
 Config files: ~/.config/fisk/monitor.conf, /etc/xdg/fisk/monitor.conf
 Environment variables: FISK_MONITOR_SCHEDULER, etc.`);
@@ -6298,7 +6299,13 @@ function notify(msg) {
         return;
     }
     const notifyNow = (message) => {
-        notificationBox.setContent(message || "");
+        if (message) {
+            notificationBox.setContent(message);
+        }
+        else {
+            updateNotificationBar();
+            return;
+        }
         screen.render();
     };
     notificationInterval = setInterval(() => {
@@ -6624,5 +6631,91 @@ function connect() {
         setTimeout(connect, 1000);
     });
 }
+// --- Daemon connection for local slot info ---
+const DaemonJSON = 5;
+const DaemonJSONResponse = 12;
+const daemonSocketPath = String(option("daemon-socket", path__default["default"].join(require$$2__default["default"].homedir(), ".cache", "fisk", "daemon", "socket")));
+let daemonSlotsInfo;
+let daemonSocket;
+let daemonRecvBuffer = Buffer.alloc(0);
+function updateNotificationBar() {
+    if (daemonSlotsInfo && daemonSlotsInfo.local.capacity > 0) {
+        const local = daemonSlotsInfo.local;
+        notificationBox.setContent(`{bold}Local:{/bold} ${local.active}/${local.capacity} active, ${local.total} total`);
+    }
+    else {
+        notificationBox.setContent("");
+    }
+    screen.render();
+}
+function processDaemonMessage(json) {
+    try {
+        const msg = JSON.parse(json);
+        if (msg.type === "slotsInfo") {
+            daemonSlotsInfo = msg;
+            updateNotificationBar();
+        }
+    }
+    catch (e) {
+        // ignore parse errors
+    }
+}
+function processDaemonData() {
+    while (daemonRecvBuffer.length > 0) {
+        const type = daemonRecvBuffer[0];
+        if (type === DaemonJSONResponse) {
+            if (daemonRecvBuffer.length < 5) {
+                break; // need more data for length header
+            }
+            const msgLen = daemonRecvBuffer.readUInt32BE(1);
+            if (daemonRecvBuffer.length < 5 + msgLen) {
+                break; // need more data for body
+            }
+            const json = daemonRecvBuffer.subarray(5, 5 + msgLen).toString("utf8");
+            daemonRecvBuffer = daemonRecvBuffer.subarray(5 + msgLen);
+            processDaemonMessage(json);
+        }
+        else {
+            // Unknown single-byte message, skip it
+            daemonRecvBuffer = daemonRecvBuffer.subarray(1);
+        }
+    }
+}
+function sendDaemonJSON(sock, obj) {
+    const jsonBuf = Buffer.from(JSON.stringify(obj), "utf8");
+    const header = Buffer.allocUnsafe(5);
+    header.writeUInt8(DaemonJSON, 0);
+    header.writeUInt32BE(jsonBuf.length, 1);
+    sock.write(header);
+    sock.write(jsonBuf);
+}
+function connectDaemon() {
+    daemonSlotsInfo = undefined;
+    daemonRecvBuffer = Buffer.alloc(0);
+    daemonSocket = require$$3__default["default"].createConnection(daemonSocketPath);
+    daemonSocket.on("connect", () => {
+        assert__default["default"](daemonSocket);
+        // Send PID (4 bytes, big-endian) as the daemon protocol requires
+        const pidBuf = Buffer.allocUnsafe(4);
+        pidBuf.writeUInt32BE(process.pid, 0);
+        daemonSocket.write(pidBuf);
+        // Subscribe to slot updates
+        sendDaemonJSON(daemonSocket, { type: "subscribeSlots" });
+    });
+    daemonSocket.on("data", (data) => {
+        daemonRecvBuffer = Buffer.concat([daemonRecvBuffer, data]);
+        processDaemonData();
+    });
+    daemonSocket.on("error", () => {
+        // Daemon may not be running, silently retry
+    });
+    daemonSocket.on("close", () => {
+        daemonSocket = undefined;
+        daemonSlotsInfo = undefined;
+        updateNotificationBar();
+        setTimeout(connectDaemon, 5000);
+    });
+}
 connect();
+connectDaemon();
 //# sourceMappingURL=fisk-monitor.js.map

package/package.json

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