@andersbakken/fisk 4.0.64 → 4.0.66

package/builder/VM_runtime.js

@@ -3071,7 +3071,9 @@ class Compile extends EventEmitter__default["default"] {
                 case "-cxx-isystem":
                 case "-isysroot":
                 case "-isystem":
+                case "-iquote":
                 case "-I":
+                case "-F":
                     args.splice(i--, 2);
                     break;
                 case "-x":
@@ -3120,7 +3122,16 @@ class Compile extends EventEmitter__default["default"] {
                     ++i;
                     break;
                 default:
-                    if (/^-mlinker-version=/.exec(args[i]) || /^-stdlib=/.exec(args[i])) {
+                    if (args[i].startsWith("-mlinker-version=") ||
+                        args[i].startsWith("-stdlib=") ||
+                        args[i].startsWith("-I") ||
+                        args[i].startsWith("-F") ||
+                        args[i].startsWith("-isystem") ||
+                        args[i].startsWith("-isysroot") ||
+                        args[i].startsWith("-cxx-isystem") ||
+                        args[i].startsWith("-iquote") ||
+                        args[i].startsWith("--sysroot=") ||
+                        args[i].startsWith("--gcc-toolchain=")) {
                         args.splice(i--, 1);
                         break;
                     }

package/builder/fisk-builder.js

@@ -60147,7 +60147,15 @@ function getFromCache(job, cb) {
                     let sendBuffer = buffer;
                     // Decompress if client doesn't support compressed responses from cache
                     if (!sendCompressed && buffer.byteLength > 0) {
-                        sendBuffer = zlib__default["default"].gunzipSync(buffer);
+                        try {
+                            sendBuffer = zlib__default["default"].gunzipSync(buffer);
+                        }
+                        catch (gunzipErr) {
+                            assert__default["default"](objectCache, "Must have objectCache");
+                            console.error(`Failed to gunzip ${path__default["default"].join(objectCache.dir, item.response.sha1)} for file index ${fileIdx}:`, gunzipErr);
+                            finish(gunzipErr);
+                            return;
+                        }
                     }
                     job.send(sendBuffer);
                     pos += read;
@@ -60501,7 +60509,22 @@ client.on("getEnvironments", (message) => {
         fs$3.mkdirpSync(dir);
         const file = path__default["default"].join(dir, "env.tar.gz");
         const writeStream = fs$3.createWriteStream(file);
+        let writeStreamFailed = false;
+        writeStream.on("error", (err) => {
+            writeStreamFailed = true;
+            console.error("Got writeStream error for", file, err);
+            try {
+                fs$3.removeSync(dir);
+            }
+            catch (rmErr) {
+                /* */
+            }
+            setTimeout(work, 0);
+        });
         writeStream.on("finish", () => {
+            if (writeStreamFailed) {
+                return;
+            }
             console.log("Got finish", env);
             exec("tar xf '" + file + "'", { cwd: dir })
                 .then(() => {
@@ -60545,24 +60568,26 @@ client.on("getEnvironments", (message) => {
         });
         axios({ method: "get", url: url, responseType: "stream" })
             .then((response) => {
+            response.data.on("error", (err) => {
+                console.error("Got error from environment download stream", url, err);
+                if (writeStream.destroy instanceof Function) {
+                    writeStream.destroy(err);
+                }
+                else {
+                    writeStream.end();
+                }
+            });
             response.data.pipe(writeStream);
-            // console
         })
             .catch((error) => {
             console.log("Got error from request", error);
+            // writeStream.on("error", ...) handles dir cleanup and work() reschedule.
             if (writeStream.destroy instanceof Function) {
-                writeStream.destroy();
+                writeStream.destroy(error instanceof Error ? error : new Error(String(error)));
             }
             else {
                 writeStream.end();
             }
-            try {
-                fs$3.removeSync(dir);
-            }
-            catch (err) {
-                /* */
-            }
-            fs$3.mkdirpSync(dir);
         });
     };
     work();

package/monitor/fisk-monitor.js

@@ -6614,6 +6614,7 @@ function connect() {
         }
         catch (e) {
             notify(`msg parse error: ${msg}, ${e}`);
+            return;
         }
         switch (obj.type) {
             case "builderAdded":

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andersbakken/fisk",
-    "version": "4.0.64",
+    "version": "4.0.66",
     "description": "Fisk, a distributed compile system",
     "scripts": {
         "lint": "eslint . --ext .ts",
@@ -74,7 +74,7 @@
         "prettier": "^2.8.2",
         "rollup": "^2.38.4",
         "rollup-plugin-hashbang": "^3.0.0",
-        "rollup-plugin-typescript2": "^0.27.0",
+        "rollup-plugin-typescript2": "^0.37.0",
         "run-p": "^0.0.0"
     }
 }

package/scheduler/fisk-scheduler.js

@@ -139,7 +139,12 @@ class Database {
                             resolve(JSON.parse(data));
                         }
                         catch (error) {
-                            fs__default["default"].renameSync(this.path, this.path + ".error");
+                            try {
+                                fs__default["default"].renameSync(this.path, this.path + ".error");
+                            }
+                            catch (renameErr) {
+                                console.error("Failed to quarantine corrupt DB file", this.path, renameErr);
+                            }
                             reject(new Error(`Failed to parse JSON from file: ${this.path} ${error.message}`));
                         }
                     }
@@ -3659,7 +3664,8 @@ class Environments {
                     if (st.isDirectory()) {
                         // we're good
                         this._path = p;
-                        fs$4.readdir(p).then((files) => {
+                        fs$4.readdir(p)
+                            .then((files) => {
                             const promises = [];
                             files.forEach((e) => {
                                 if (e.length === 47 && e.indexOf(".tar.gz", 40) === 40) {
@@ -3678,13 +3684,12 @@ class Environments {
                                     }));
                                 }
                             });
-                            Promise.all(promises).then(() => {
+                            return Promise.all(promises).then(() => {
                                 resolve();
                             });
-                            // setTimeout(() => {
-                            //     // console.log(JSON.stringify(environments._links, null, 4));
-                            //     this.link("28CD22DF1176120F63EC463E095F13D4330194D7", "177EF462A7AEC31C26502F5833A92B51C177C01B", [], []);
-                            // }, 1000);
+                        })
+                            .catch((err) => {
+                            reject(`Failed to read environments directory ${p}: ${err}`);
                         });
                     }
                     else {
@@ -3720,15 +3725,12 @@ class Environments {
         return new File(path__default["default"].join(this._path, `${environment.hash}.tar.gz`), environment.hash);
     }
     complete(file) {
-        return new Promise((resolve) => {
-            untarFile(file.path, "etc/compiler_info").then((data) => {
-                const idx = data.indexOf("\n");
-                const info = JSON.parse(data.substr(0, idx));
-                const env = new Environment(file.path, file.hash, info.system, info.originalPath);
-                env.info = data.substr(idx + 1);
-                this._data[file.hash] = env;
-                resolve();
-            });
+        return untarFile(file.path, "etc/compiler_info").then((data) => {
+            const idx = data.indexOf("\n");
+            const info = JSON.parse(data.substr(0, idx));
+            const env = new Environment(file.path, file.hash, info.system, info.originalPath);
+            env.info = data.substr(idx + 1);
+            this._data[file.hash] = env;
         });
     }
     hasEnvironment(hash) {
@@ -3807,21 +3809,24 @@ class Environments {
         return this._db.set("links", this.linksInfo());
     }
     remove(hash) {
-        // ### this should be promisified
         const env = this._data[hash];
         if (!env) {
             return;
         }
         try {
             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", env.path, err);
+            return;
         }
+        delete this._data[hash];
+        this.unlink(hash)
+            .then(() => this.unlink(undefined, hash))
+            .then(() => this.syncLinks())
+            .catch((err) => {
+            console.error("Failed to unlink environment metadata", env.path, err);
+        });
     }
 }
 Environments.instance = new Environments();
@@ -58415,6 +58420,12 @@ server.on("listen", (app) => {
         rstream.on("error", (err) => {
             console.error("Got read stream error for", env.path, err);
             rstream.close();
+            if (!res.headersSent) {
+                res.sendStatus(500);
+            }
+            else {
+                res.destroy(err);
+            }
         });
         rstream.pipe(res);
     });