@andersbakken/fisk 4.0.56 → 4.0.57

package/daemon/fisk-daemon.js

@@ -3345,16 +3345,28 @@ 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;
@@ -3362,9 +3374,11 @@ class Slots extends EventEmitter__default["default"] {
     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 {
@@ -3388,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() {
@@ -4183,6 +4199,39 @@ 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 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;
@@ -4206,6 +4255,26 @@ server.on("compile", (compile) => {
         }
         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", () => {

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.56",
+    "version": "4.0.57",
     "description": "Fisk, a distributed compile system",
     "scripts": {
         "lint": "eslint . --ext .ts",