Simplify timeout logic

This commit simplifies the timeout logic by no longer passing `timeout`
to `spawn`. Instead, the full timeout logic is handled by `run`, which
sets a timeout and determines whether the process was killed. Now that
there is no duplicate logic, `wasKilledByTimeout` can be removed
in favor of checking `killedByTimeout` directly.

Author: BrendanC23

lib/java-caller.js

@@ -107,25 +107,6 @@ class JavaCaller {
         let timeoutId;
         let killedByTimeout = false;
 
-        const wasKilledByTimeout = (code, signal) => {
-            if (!runOptions.timeout) {
-                return false;
-            }
-            if (killedByTimeout) {
-                return true;
-            }
-            if (signal && signal === runOptions.killSignal) {
-                return true;
-            }
-            const signals = os.constants && os.constants.signals ? os.constants.signals : {};
-            if (typeof runOptions.killSignal === "string" && signals[runOptions.killSignal] && code === 128 + signals[runOptions.killSignal]) {
-                return true;
-            }
-            if (typeof runOptions.killSignal === "number" && code === 128 + runOptions.killSignal) {
-                return true;
-            }
-            return false;
-        };
         const prom = new Promise((resolve) => {
             // Spawn java command line
             debug(`Java command: ${javaExeToUse} ${javaArgs.join(" ")}`);
@@ -136,8 +117,6 @@ class JavaCaller {
                 stdio: this.output === "console" ? "inherit" : runOptions.detached ? "ignore" : "pipe",
                 windowsHide: true,
                 windowsVerbatimArguments: runOptions.windowsVerbatimArguments,
-                timeout: runOptions.timeout,
-                killSignal: runOptions.killSignal,
             };
             if (javaExeToUse.includes(" ")) {
                 spawnOptions.shell = true;
@@ -147,9 +126,9 @@ class JavaCaller {
             if (runOptions.timeout) {
                 timeoutId = setTimeout(() => {
                     if (!child.killed) {
-                        killedByTimeout = true;
                         try {
                             child.kill(runOptions.killSignal);
+                            killedByTimeout = true;
                         } catch (err) {
                             stderr += `Failed to kill process after ${runOptions.timeout}ms: ${err.message}`;
                         }
@@ -172,6 +151,11 @@ class JavaCaller {
             child.on("error", (data) => {
                 this.status = 666;
                 stderr += "Java spawn error: " + data;
+
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+
                 resolve();
             });
 
@@ -181,8 +165,8 @@ class JavaCaller {
                     clearTimeout(timeoutId);
                 }
 
-                if (wasKilledByTimeout(code, signal)) {
-                    // Process was terminated because of the timeout, either via our fallback timer or the built-in spawn timeout
+                if (killedByTimeout) {
+                    // Process was terminated because of the timeout
                     this.status = 666;
                     stderr += `Process timed out with ${runOptions.killSignal} after ${runOptions.timeout}ms.`;
                 } else {

test/java-caller.test.js

@@ -200,7 +200,7 @@ describe("Call with classes", () => {
         checkStdOutIncludes(`JavaCallerTester is called !`, stdout, stderr);
     });
 
-        it("should terminate once timeout is reached", async () => {
+    it("should terminate once timeout is reached", async () => {
         const java = new JavaCaller({
             classPath: 'test/java/dist',
             mainClass: 'com.nvuillam.javacaller.JavaCallerTester'