@andersbakken/fisk 4.0.32 → 4.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andersbakken/fisk",
-    "version": "4.0.32",
+    "version": "4.0.33",
     "description": "Fisk, a distributed compile system",
     "scripts": {
         "lint": "eslint . --ext .ts",
@@ -58,7 +58,7 @@
         "@types/fs-extra": "^9.0.13",
         "@types/humanize-duration": "^3.27.1",
         "@types/minimist": "^1.2.2",
-        "@types/node": "^14.14.25",
+        "@types/node": "^14.18.63",
         "@types/posix": "^4.2.0",
         "@types/url-parse": "^1.4.8",
         "@types/ws": "^8.5.3",

package/scheduler/fisk-scheduler.js

@@ -52141,7 +52141,7 @@ class Server extends require$$0__default$2["default"] {
         return this.app;
     }
     listen() {
-        return new Promise((resolve) => {
+        return new Promise((resolve, reject) => {
             this.app = express();
             this.app.use(bodyParser.urlencoded({ extended: true }));
             this.emit("listen", this.app);
@@ -52152,8 +52152,20 @@ class Server extends require$$0__default$2["default"] {
                 });
             }
             this.server = require$$2__default["default"].createServer(this.app);
-            this.ws = new ws.Server({ noServer: true });
-            const port = this.option.int("port", 8097);
+            const keyFile = this.option.string("key");
+            const certFile = this.option.string("cert");
+            let key;
+            let cert;
+            if (keyFile && certFile) {
+                try {
+                    key = fs__default["default"].readFileSync(keyFile);
+                    cert = fs__default["default"].readFileSync(certFile);
+                }
+                catch (err) {
+                    reject(new Error(`Failed to read key (${keyFile}) or cert (${certFile}): ${err.message}`));
+                    return;
+                }
+            }
             let defaultBacklog = 128;
             try {
                 defaultBacklog = parseInt(fs__default["default"].readFileSync("/proc/sys/net/core/somaxconn", "utf8")) || 128;
@@ -52162,6 +52174,9 @@ class Server extends require$$0__default$2["default"] {
                 /* */
             }
             const backlog = this.option.int("backlog", defaultBacklog);
+            this.ws = new ws.Server({ noServer: true });
+            let waitingServers = 1;
+            const port = this.option.int("port", 8097);
             this.server.listen({ port, backlog, host: "0.0.0.0" });
             this.server.on("upgrade", (req, socket, head) => {
                 assert__default["default"](this.ws);
@@ -52169,15 +52184,6 @@ class Server extends require$$0__default$2["default"] {
                     this._handleConnection(ws, req);
                 });
             });
-            this.ws.on("headers", (headers, request) => {
-                const url = new urlParse(request.url, this.baseUrl);
-                headers.push("x-fisk-object-cache: " + (this.objectCache ? "true" : "false"));
-                if (url.pathname === "/monitor") {
-                    const nonce = crypto__default["default"].randomBytes(256).toString("base64");
-                    headers.push(`x-fisk-nonce: ${nonce}`);
-                    this.nonces.set(request, nonce);
-                }
-            });
             this.server.on("error", (error) => {
                 if (error.code === "EADDRINUSE") {
                     console.log(`Port ${port} is in use...`);
@@ -52192,8 +52198,51 @@ class Server extends require$$0__default$2["default"] {
                 }
             });
             this.server.once("listening", () => {
-                console.log("listening on", port);
-                resolve();
+                console.log("http://listening on", port);
+                if (!--waitingServers) {
+                    resolve();
+                }
+            });
+            let securePort;
+            if (key && cert) {
+                securePort = this.option.int("securePort", 8098);
+                this.secureServer = require$$1__default$1["default"].createServer({ key, cert }, this.app);
+                this.secureServer.listen({ port: securePort, backlog, host: "0.0.0.0" });
+                ++waitingServers;
+                this.secureServer.on("error", (error) => {
+                    if (error.code === "EADDRINUSE") {
+                        console.log(`Port ${securePort} is in use...`);
+                        setTimeout(() => {
+                            assert__default["default"](this.secureServer);
+                            this.secureServer.listen({ port: securePort, backlog, host: "0.0.0.0" });
+                        }, 1000);
+                    }
+                    else {
+                        console.error("Got secure server error", error.message);
+                        this.emit("error", error);
+                    }
+                });
+                this.secureServer.on("upgrade", (req, socket, head) => {
+                    assert__default["default"](this.ws);
+                    this.ws.handleUpgrade(req, socket, head, (ws) => {
+                        this._handleConnection(ws, req);
+                    });
+                });
+                this.secureServer.once("listening", () => {
+                    console.log("https://listening on", securePort);
+                    if (!--waitingServers) {
+                        resolve();
+                    }
+                });
+            }
+            this.ws.on("headers", (headers, request) => {
+                const url = new urlParse(request.url, this.baseUrl);
+                headers.push("x-fisk-object-cache: " + (this.objectCache ? "true" : "false"));
+                if (url.pathname === "/monitor") {
+                    const nonce = crypto__default["default"].randomBytes(256).toString("base64");
+                    headers.push(`x-fisk-nonce: ${nonce}`);
+                    this.nonces.set(request, nonce);
+                }
             });
         });
     }