@andersbakken/fisk 4.0.57 → 4.0.61

package/builder/VM_runtime.js

@@ -3225,6 +3225,7 @@ class Compile extends EventEmitter__default["default"] {
         proc.on("exit", (exitCode) => {
             // try {
             const files = [];
+            let addDirError;
             const addDir = (directory, prefix) => {
                 try {
                     fs.readdirSync(directory).forEach((file) => {
@@ -3241,21 +3242,21 @@ class Compile extends EventEmitter__default["default"] {
                                 if (file === outputFileName) {
                                     files.push({ path: output, mapped: path__default["default"].join(prefix, file) });
                                 }
-                                else if (path__default["default"].extname(file) === ".gcno") {
-                                    // console.log("mapping", output, prefix, file);
-                                    files.push({
-                                        path: output.substring(0, output.length - 1) + "gcno",
-                                        mapped: path__default["default"].join(prefix, file)
-                                    });
-                                }
-                                else if (path__default["default"].extname(file) === ".gcda") {
-                                    files.push({
-                                        path: output.substring(0, output.length - 1) + "gcda",
-                                        mapped: path__default["default"].join(prefix, file)
-                                    });
-                                }
                                 else {
-                                    files.push({ path: path__default["default"].join(prefix, file) });
+                                    const ext = path__default["default"].extname(file);
+                                    switch (ext) {
+                                        case ".gcno":
+                                        case ".gcda":
+                                        case ".dwo":
+                                            files.push({
+                                                path: output.substring(0, output.length - 2) + ext,
+                                                mapped: path__default["default"].join(prefix, file)
+                                            });
+                                            break;
+                                        default:
+                                            files.push({ path: path__default["default"].join(prefix, file) });
+                                            break;
+                                    }
                                 }
                                 if (debug) {
                                     console.log("Added file", file, files[files.length - 1]);
@@ -3269,23 +3270,26 @@ class Compile extends EventEmitter__default["default"] {
                 }
                 catch (err) {
                     console.error("Got an error processing outputs for", sourcePath, err);
-                    assert__default["default"](sourcePath !== undefined, "Must have sourcePath");
-                    const errorExitEvent = {
-                        exitCode: 110,
-                        files: [],
-                        error: err.toString(),
-                        sourcePath
-                    };
-                    this.emit("exit", errorExitEvent);
+                    addDirError = err;
                 }
             };
             if (exitCode === 0) {
                 addDir(dir, dir);
             }
+            assert__default["default"](sourcePath !== undefined, "Must have sourcePath4");
+            if (addDirError) {
+                const errorExitEvent = {
+                    exitCode: 110,
+                    files: [],
+                    error: addDirError.toString(),
+                    sourcePath
+                };
+                this.emit("exit", errorExitEvent);
+                return;
+            }
             if (exitCode === null) {
                 exitCode = 111;
             }
-            assert__default["default"](sourcePath !== undefined, "Must have sourcePath4");
             const exitEvent = { exitCode, files, sourcePath };
             this.emit("exit", exitEvent);
         });

package/builder/fisk-builder.js

@@ -7965,7 +7965,10 @@ class ObjectCache extends EventEmitter__default["default"] {
     }
     loadFile(filePath, fileSize) {
         const fileName = path__default["default"].basename(filePath);
-        // console.log("got file", filePath, fileSize);
+        // Skip if already cached — makes loadFile idempotent
+        if (fileName in this.cache) {
+            return;
+        }
         let fd;
         let jsonBuffer;
         try {
@@ -7993,6 +7996,9 @@ class ObjectCache extends EventEmitter__default["default"] {
                 this.size += item.fileSize;
                 this.cache[fileName] = item;
                 this.emit("added", { sha1: response.sha1, sourcePath: response.sourcePath, fileSize: stat.size });
+                if (this.size > this.maxSize) {
+                    this.purge(this.purgeSize);
+                }
             }
             else {
                 throw new Error("Unexpected file " + fileName);
@@ -8010,7 +8016,6 @@ class ObjectCache extends EventEmitter__default["default"] {
                 console.error("Can't even delete this one", doubleError);
             }
         }
-        return undefined;
     }
     state(sha1) {
         if (sha1 in this.cache) {
@@ -8068,13 +8073,12 @@ class ObjectCache extends EventEmitter__default["default"] {
                         throw new Error(`Wrong file size for ${path__default["default"].join(this.dir, response.sha1)}, should have been ${cacheItem.fileSize} but ended up being ${stat.size}`);
                     }
                     this.cache[response.sha1] = cacheItem;
-                    // console.log(response);
+                    this.size += cacheItem.fileSize;
                     this.emit("added", {
                         sha1: response.sha1,
                         sourcePath: response.sourcePath,
                         fileSize: cacheItem.fileSize
                     });
-                    this.size += cacheItem.fileSize;
                     if (this.size > this.maxSize) {
                         this.purge(this.purgeSize);
                     }
@@ -55000,7 +55004,7 @@ class CompileJob extends EventEmitter__default["default"] {
         fs$3.writeSync(this.fd, data);
         this.cppSize += data.length;
         this.startCompile = Date.now();
-        fs$3.close(this.fd);
+        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));
     }
@@ -60063,6 +60067,7 @@ process.on("uncaughtException", (err) => {
 });
 let debug = option("debug");
 let objectCache;
+let fetchSequence = 0;
 function getFromCache(job, cb) {
     // console.log("got job", job.sha1, objectCache ? objectCache.state(job.sha1) : false);
     // if (objectCache)
@@ -60216,71 +60221,88 @@ client.on("fetch_cache_objects", (msg) => {
     for (let idx = 0; idx < max; ++idx) {
         promises.push(Promise.resolve());
     }
+    const fetchTimeoutMs = option.int("object-cache-fetch-timeout", 5 * 60 * 1000);
     message.objects.forEach((operation, idx) => {
         promises[idx % promises.length] = promises[idx % promises.length].then(() => {
             return new Promise((resolve) => {
                 assert__default["default"](objectCache, "Must have objectCache");
-                const file = path__default["default"].join(objectCache.dir, operation.sha1);
+                if (objectCache.state(operation.sha1) !== "none") {
+                    console.log("Skipping", operation.sha1, "already", objectCache.state(operation.sha1));
+                    resolve();
+                    return;
+                }
+                const finalPath = path__default["default"].join(objectCache.dir, operation.sha1);
+                const tmpPath = finalPath + ".tmp." + process.pid + "." + ++fetchSequence;
                 const url = `http://${operation.source}/objectcache/${operation.sha1}`;
-                console.log("Downloading", url, "->", file);
+                console.log("Downloading", url, "->", tmpPath);
                 let expectedSize;
                 let writeStream;
-                try {
-                    writeStream = fs$3.createWriteStream(file);
-                }
-                catch (err) {
-                    console.error("Got some error from write stream", err);
+                let resolved = false;
+                const cleanup = () => {
                     try {
-                        fs$3.unlinkSync(file);
+                        fs$3.unlinkSync(tmpPath);
                     }
                     catch (e) {
                         /* */
                     }
-                    resolve();
+                    if (!resolved) {
+                        resolved = true;
+                        resolve();
+                    }
+                };
+                try {
+                    writeStream = fs$3.createWriteStream(tmpPath);
+                }
+                catch (err) {
+                    console.error("Failed to create write stream for", tmpPath, err);
+                    cleanup();
                     return;
                 }
-                axios({ method: "get", url: url, responseType: "stream" })
+                axios({ method: "get", url: url, responseType: "stream", timeout: fetchTimeoutMs })
                     .then((response) => {
                     expectedSize = parseInt(response.headers["content-length"]);
                     response.data.pipe(writeStream);
                     response.data.on("error", (err) => {
-                        console.error("Got some error from stream", err);
+                        console.error("Got http stream error for", operation.sha1, err);
                         writeStream.destroy(new Error("http stream error " + err.toString()));
                     });
-                    // console
                 })
                     .catch((err) => {
-                    console.error("Got some error", err);
+                    console.error("Got http error fetching", operation.sha1, err);
                     writeStream.destroy(new Error("http error " + err.toString()));
                 });
                 writeStream.on("finish", () => {
-                    console.log("Finished writing file", file);
                     let stat;
                     try {
-                        stat = fs$3.statSync(file);
+                        stat = fs$3.statSync(tmpPath);
                     }
                     catch (err) {
                         /* */
                     }
                     if (!stat || stat.size !== expectedSize) {
-                        console.log("Got wrong size for", file, url, "\nGot", stat ? stat.size : -1, "expected", expectedSize);
+                        console.log("Got wrong size for", operation.sha1, url, "\nGot", stat ? stat.size : -1, "expected", expectedSize);
+                        cleanup();
+                    }
+                    else {
                         try {
-                            fs$3.unlinkSync(file);
+                            fs$3.renameSync(tmpPath, finalPath);
+                            ++filesReceived;
+                            assert__default["default"](objectCache, "Must have objectcache");
+                            objectCache.loadFile(finalPath, stat.size);
                         }
                         catch (err) {
-                            // console.log("Got error unlinking file", file, err);
+                            console.error("Failed to rename", tmpPath, "to", finalPath, err);
+                            cleanup();
                         }
                     }
-                    else {
-                        ++filesReceived;
-                        assert__default["default"](objectCache, "Must have objectcache");
-                        objectCache.loadFile(file, stat.size);
+                    if (!resolved) {
+                        resolved = true;
+                        resolve();
                     }
-                    resolve();
                 });
                 writeStream.on("error", (err) => {
-                    console.error("Got stream error", err);
-                    resolve();
+                    console.error("Got stream error for", operation.sha1, err);
+                    cleanup();
                 });
             });
         });
@@ -60288,10 +60310,6 @@ client.on("fetch_cache_objects", (msg) => {
     Promise.all(promises).then(() => {
         console.log("got results", filesReceived);
     });
-    // chain.then(() => {
-    //     console.log("Received", filesReceived, "files. Restarting");
-    //     process.exit();
-    // });
 });
 const environmentsRoot = path__default["default"].join(common.cacheDir(), "environments");
 function exec(command, opts) {
@@ -60454,7 +60472,10 @@ client.on("getEnvironments", (message) => {
     base += "/environment/";
     const work = () => {
         if (!message.environments.length) {
-            const restart = option("restart-on-new-environments");
+            let restart = option("restart-on-new-environments");
+            if (restart === "false" || restart === "0") {
+                restart = false;
+            }
             if (!restart) {
                 setTimeout(() => {
                     client.send("environments", { environments: Object.keys(environments) });
@@ -60607,7 +60628,7 @@ server.on("headers", (headers, req) => {
         wait = true;
     }
     else if (jobQueue.length >= client.slots) {
-        const priority = parseInt(req.headers["x-fisk-sha1"]) || 0;
+        const priority = parseInt(String(req.headers["x-fisk-priority"])) || 0;
         let idx = jobQueue.length - 1;
         while (idx >= client.slots) {
             const job = jobQueue[idx].job;
@@ -60659,7 +60680,13 @@ server.on("listen", (app) => {
             const rstream = fs$3.createReadStream(file);
             rstream.on("error", (err) => {
                 console.error("Got read stream error for", file, err);
-                rstream.close();
+                rstream.destroy();
+                if (!res.headersSent) {
+                    res.sendStatus(500);
+                }
+                else {
+                    res.destroy();
+                }
             });
             rstream.pipe(res);
         }
@@ -60818,11 +60845,12 @@ server.on("job", (job) => {
                         const original = contents.find((c) => c.path === item.path);
                         assert__default["default"](original, "Must have original contents");
                         assert__default["default"](original.uncompressed, "Must have uncompressed data");
-                        return {
+                        const ret = {
                             path: item.path,
                             bytes: item.contents.length,
                             uncompressedSize: original.uncompressed.byteLength
                         };
+                        return ret;
                     }),
                     success: event.success,
                     exitCode: event.exitCode,

package/monitor/fisk-monitor.js

@@ -6143,8 +6143,9 @@ clientBox.on("select", (ev) => {
         if (jobs) {
             // clientBox.current = clientKey;
             let str = "";
-            const data = [["Source file", "Builder", "Start time"]];
-            const widest = [data[0][0].length + 1, data[0][1].length + 1];
+            const header = ["Source file", "Builder", "Start time"];
+            const rows = [];
+            const widest = [header[0].length + 1, header[1].length + 1];
             const now = Date.now();
             for (const [jobKey, jobValue] of jobs) {
                 if (jobKey === "total") {
@@ -6152,15 +6153,19 @@ clientBox.on("select", (ev) => {
                 }
                 const sourceBasename = path__default["default"].basename(jobValue.sourcePath || jobValue.sourceFile || "");
                 widest[0] = Math.max(sourceBasename.length + 1, widest[0]);
-                data.push([
-                    sourceBasename,
-                    jobValue.builder.ip + ":" + jobValue.builder.port,
-                    humanizeDuration(now - jobValue.time)
-                ]);
-                widest[1] = Math.max(widest[1], data[data.length - 1][1].length + 1);
+                const ageMs = now - jobValue.time;
+                const row = {
+                    source: sourceBasename,
+                    builder: jobValue.builder.ip + ":" + jobValue.builder.port,
+                    humanizedAge: humanizeDuration(ageMs),
+                    ageMs
+                };
+                rows.push(row);
+                widest[1] = Math.max(widest[1], row.builder.length + 1);
             }
-            data.sort((a, b) => parseInt(a[2]) - parseInt(b[2]));
-            data.forEach((line, idx) => {
+            rows.sort((a, b) => a.ageMs - b.ageMs);
+            const lines = [header, ...rows.map((r) => [r.source, r.builder, r.humanizedAge])];
+            lines.forEach((line, idx) => {
                 if (!idx) {
                     str += "{bold}";
                 }

package/package.json

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

package/scheduler/fisk-scheduler.js

@@ -87,11 +87,21 @@ class Database {
                         records = {};
                     }
                     records[key] = value;
-                    fs__default["default"].writeFile(this.path + ".tmp", JSON.stringify(records) + "\n", () => {
-                        fs__default["default"].rename(this.path + ".tmp", this.path, () => {
-                            resolve();
+                    fs__default["default"].writeFile(this.path + ".tmp", JSON.stringify(records) + "\n", (writeErr) => {
+                        if (writeErr) {
+                            reject(writeErr);
+                            this.finishedOperation();
+                            return;
+                        }
+                        fs__default["default"].rename(this.path + ".tmp", this.path, (renameErr) => {
+                            if (renameErr) {
+                                reject(renameErr);
+                            }
+                            else {
+                                resolve();
+                            }
+                            this.finishedOperation();
                         });
-                        this.finishedOperation();
                     });
                 })
                     .catch((err) => {
@@ -3768,9 +3778,11 @@ class Environments {
         }
         else {
             const targets = this._links[srcHash];
-            targets.unset(targetHash);
-            if (!targets.size) {
-                delete this._links[srcHash];
+            if (targets) {
+                targets.unset(targetHash);
+                if (!targets.size) {
+                    delete this._links[srcHash];
+                }
             }
         }
         return this.syncLinks();
@@ -3796,15 +3808,19 @@ class Environments {
     }
     remove(hash) {
         // ### this should be promisified
+        const env = this._data[hash];
+        if (!env) {
+            return;
+        }
         try {
-            fs$4.removeSync(this._data[hash].path);
+            fs$4.removeSync(env.path);
             delete this._data[hash];
             this.unlink(hash);
             this.unlink(undefined, hash);
             this.syncLinks();
         }
         catch (err) {
-            console.error("Failed to remove environment", this._data[hash].path, err);
+            console.error("Failed to remove environment", env.path, err);
         }
     }
 }
@@ -3953,7 +3969,9 @@ function prettySize(bytes) {
 function addToSHA1Map(bySHA1, sha1, fileSize, node) {
     const data = bySHA1.get(sha1);
     if (data) {
-        data.nodes.push(node);
+        if (data.nodes.indexOf(node) === -1) {
+            data.nodes.push(node);
+        }
         return data.nodes.length;
     }
     bySHA1.set(sha1, new SHA1Data(fileSize, node));
@@ -3977,21 +3995,32 @@ function removeFromSHA1Map(bySHA1, sha1, node) {
         console.error("We don't have", sha1);
     }
 }
+function pendingKey(sha1, node) {
+    return sha1 + ":" + node.ip + ":" + node.port;
+}
 class ObjectCacheManager extends require$$0__default$2["default"] {
     constructor(option) {
         super();
         this.hits = 0;
         this.bySHA1 = new Map();
         this.byNode = new Map();
+        this.pendingTransfers = new Set();
+        this.pendingTransferTimers = new Map();
         this.redundancy = option.int("object-cache-redundancy", 1);
         if (this.redundancy <= 0) {
             this.redundancy = 1;
         }
+        this.pendingTransferTimeoutMs = option.int("object-cache-transfer-timeout", 5 * 60 * 1000);
         this.distributeOnInsertion = Boolean(option("distribute-object-cache-on-insertion"));
         this.distributeOnCacheHit = Boolean(option("distribute-object-cache-on-cache-hit"));
     }
     clear() {
         this.hits = 0;
+        for (const timer of this.pendingTransferTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.pendingTransfers.clear();
+        this.pendingTransferTimers.clear();
         this.emit("cleared");
     }
     hit(sha1) {
@@ -4008,7 +4037,10 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
         const nodeData = this.byNode.get(node);
         console.log("adding", msg.sourcePath, msg.sha1, "for", node.ip + ":" + node.port, nodeData ? nodeData.sha1s.length : -1);
         if (nodeData) {
-            nodeData.sha1s.push(msg.sha1);
+            this.clearPendingTransfer(msg.sha1, node);
+            if (nodeData.sha1s.indexOf(msg.sha1) === -1) {
+                nodeData.sha1s.push(msg.sha1);
+            }
             nodeData.size = msg.cacheSize;
             const count = addToSHA1Map(this.bySHA1, msg.sha1, msg.fileSize, node);
             if (this.distributeOnInsertion && count - 1 < this.redundancy) {
@@ -4057,6 +4089,7 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
             return;
         }
         this.byNode.delete(node);
+        this.clearAllPendingForNode(node);
         nodeData.sha1s.forEach((sha1) => {
             removeFromSHA1Map(this.bySHA1, sha1, node);
         });
@@ -4081,7 +4114,7 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
                     data.name = key.name;
                 }
                 if (key.hostname) {
-                    data.name = key.hostname;
+                    data.hostname = key.hostname;
                 }
                 nodes[key.ip + ":" + key.port] = data;
             });
@@ -4110,11 +4143,12 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
         if (isNaN(max) || max <= 0) {
             max = undefined;
         }
-        const sha1 = String(query.sha1);
+        const sha1 = query.sha1 && typeof query.sha1 === "string" ? query.sha1 : undefined;
+        const nodeRestriction = query.node && typeof query.node === "string" ? query.node : undefined;
         let ret;
         if (res) {
             ret = { type: "fetch_cache_objects", dry: dry, commands: {} };
-            console.log("distribute called with redundancy of", redundancy, "and max of", max, "dry", dry, "sha1", sha1);
+            console.log("distribute called with redundancy of", redundancy, "and max of", max, "dry", dry, "sha1", sha1 || "(all)");
         }
         const nodes = Array.from(this.byNode.keys());
         let nodeIdx = 0;
@@ -4124,23 +4158,20 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
                 commands.set(key, { objects: [], available: value.maxSize - value.size });
             });
         }
-        const nodeRestriction = query.node;
         let count = 0;
-        // console.log(commands);
         if (this.byNode.size >= 2) {
-            // let max = 1;
             let roundRobinIndex = 0;
             const processObject = (sha, value) => {
                 if (max !== undefined && max <= 0) {
                     return;
                 }
-                const needed = Math.min(redundancy + 1 - value.nodes.length, this.byNode.size - 1);
+                const pendingCount = this.pendingCountForSha1(sha);
+                const totalCopies = value.nodes.length + pendingCount;
+                const needed = Math.min(redundancy + 1 - totalCopies, this.byNode.size - 1);
                 if (needed > 0) {
-                    const needed2 = redundancy + 1 - value.nodes.length;
-                    // console.log("should distribute", key, "to", needed, "nodes");
                     let firstIdx;
                     let found = 0;
-                    while (found < needed2) {
+                    while (found < needed) {
                         if (++nodeIdx === nodes.length) {
                             nodeIdx = 0;
                         }
@@ -4154,6 +4185,12 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
                         if (value.nodes.indexOf(node) !== -1) {
                             continue;
                         }
+                        if (this.hasPendingTransfer(sha, node)) {
+                            continue;
+                        }
+                        if (nodeRestriction && node.ip + ":" + node.port !== nodeRestriction) {
+                            continue;
+                        }
                         let data = commands.get(node);
                         let available;
                         if (data) {
@@ -4179,7 +4216,6 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
                             break;
                         }
                     }
-                    // console.log("found candidates", candidates.map(node => node.ip + ":" + node.port));
                 }
             };
             if (sha1) {
@@ -4198,14 +4234,16 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
             }
         }
         commands.forEach((value, key) => {
-            // console.log(key.ip + ": " + key.port, "will receive", value.objects);
-            if (value.objects.length && (!nodeRestriction || key.ip + ":" + key.port === nodeRestriction)) {
+            if (value.objects.length) {
                 console.log(`sending ${value.objects.length}/${this.bySHA1.size} fetch_cache_objects to ${key.ip}:${key.port}`);
                 if (ret) {
-                    ret[`${key.ip}:${key.port}`] = value.objects;
+                    ret.commands[`${key.ip}:${key.port}`] = value.objects;
                 }
                 count += value.objects.length;
                 if (!dry) {
+                    for (const obj of value.objects) {
+                        this.addPendingTransfer(obj.sha1, key);
+                    }
                     key.send({ type: "fetch_cache_objects", objects: value.objects });
                 }
             }
@@ -4213,9 +4251,52 @@ class ObjectCacheManager extends require$$0__default$2["default"] {
         if (ret && res) {
             ret.count = count;
             res.send(JSON.stringify(ret, null, 4) + "\n");
-            // } else if (res) {
         }
     }
+    addPendingTransfer(sha1, node) {
+        const key = pendingKey(sha1, node);
+        this.pendingTransfers.add(key);
+        const timer = setTimeout(() => {
+            this.pendingTransfers.delete(key);
+            this.pendingTransferTimers.delete(key);
+        }, this.pendingTransferTimeoutMs);
+        timer.unref();
+        this.pendingTransferTimers.set(key, timer);
+    }
+    clearPendingTransfer(sha1, node) {
+        const key = pendingKey(sha1, node);
+        this.pendingTransfers.delete(key);
+        const timer = this.pendingTransferTimers.get(key);
+        if (timer) {
+            clearTimeout(timer);
+            this.pendingTransferTimers.delete(key);
+        }
+    }
+    clearAllPendingForNode(node) {
+        const suffix = ":" + node.ip + ":" + node.port;
+        for (const key of this.pendingTransfers) {
+            if (key.endsWith(suffix)) {
+                this.pendingTransfers.delete(key);
+                const timer = this.pendingTransferTimers.get(key);
+                if (timer) {
+                    clearTimeout(timer);
+                    this.pendingTransferTimers.delete(key);
+                }
+            }
+        }
+    }
+    pendingCountForSha1(sha1) {
+        let count = 0;
+        for (const key of this.pendingTransfers) {
+            if (key.startsWith(sha1 + ":")) {
+                ++count;
+            }
+        }
+        return count;
+    }
+    hasPendingTransfer(sha1, node) {
+        return this.pendingTransfers.has(pendingKey(sha1, node));
+    }
 }
 
 class Peak {
@@ -56039,7 +56120,6 @@ class Server extends require$$0__default$2["default"] {
         }
         this.emit("compile", client);
         const remaining = {};
-        client.ws.on("close", (status, reason) => client.emit("close", status, reason));
         client.ws.on("error", (err) => client.emit("error", err));
         client.ws.on("close", (code, reason) => {
             if (remaining.bytes) {
@@ -57843,7 +57923,7 @@ process.on("uncaughtException", (err) => {
 });
 const monitorsLog = option("monitor-log");
 server.on("error", (error) => {
-    throw new error();
+    throw error;
 });
 let schedulerNpmVersion;
 try {
@@ -58305,7 +58385,6 @@ server.on("listen", (app) => {
         }
         else if (req.query && "distribute" in req.query) {
             objectCache.distribute(req.query, res);
-            res.sendStatus(200);
         }
         else {
             const pretty = req.query && req.query.unpretty ? undefined : 4;
@@ -58605,8 +58684,9 @@ function requestEnvironment(compile) {
                     file = undefined;
                     // send any new environments to builders
                     delete pendingEnvironments[hsh];
-                    purgeEnvironmentsToMaxSize();
+                    return purgeEnvironmentsToMaxSize();
                 }
+                return undefined;
             })
                 .then(() => {
                 if (env.last) {
@@ -58697,20 +58777,24 @@ server.on("compile", (compile) => {
                 if (!filterBuilder(s)) {
                     return;
                 }
+                let candidateEnv;
+                for (let i = 0; i < usableEnvs.length; ++i) {
+                    if (usableEnvs[i] in s.environments) {
+                        candidateEnv = usableEnvs[i];
+                        break;
+                    }
+                }
+                if (!candidateEnv) {
+                    return;
+                }
                 const builderScore = score(s);
                 if (!builder ||
                     builderScore > bestScore ||
-                    (builderScore === bestScore && builder.lastJob < s.lastJob)) {
+                    (builderScore === bestScore && s.lastJob < builder.lastJob)) {
                     bestScore = builderScore;
                     builder = s;
                     foundInCache = true;
-                    // Find which usable environment this builder has
-                    for (let i = 0; i < usableEnvs.length; ++i) {
-                        if (usableEnvs[i] in s.environments) {
-                            env = usableEnvs[i];
-                            break;
-                        }
-                    }
+                    env = candidateEnv;
                 }
             });
         }
@@ -58949,14 +59033,22 @@ server.on("monitor", (client) => {
                     monitors.forEach((monitor) => {
                         monitor.send(info);
                     });
+                })
+                    .catch((err) => {
+                    console.error("Failed to link environments", err);
                 });
                 break;
             case "unlinkEnvironments":
-                Environments.instance.unlink(message.srcHash, message.targetHash).then(() => {
+                Environments.instance
+                    .unlink(message.srcHash, message.targetHash)
+                    .then(() => {
                     const info = { type: "listEnvironments", environments: environmentsInfo() };
                     monitors.forEach((monitor) => {
                         monitor.send(info);
                     });
+                })
+                    .catch((err) => {
+                    console.error("Failed to unlink environments", err);
                 });
                 break;
             case "listUsers": {
@@ -59042,7 +59134,7 @@ server.on("monitor", (client) => {
                         else if (users[message.user].cookieIp !== client.ip) {
                             throw new Error("Wrong ip address");
                         }
-                        else if (users[message.user].cookieExpiration || 0 <= Date.now()) {
+                        else if ((users[message.user].cookieExpiration || 0) <= Date.now()) {
                             throw new Error("Cookie expired");
                         }
                         else {