@jsenv/core 23.1.3 → 23.2.2

package/src/internal/node-launcher/createChildProcessOptions.js

@@ -1,4 +1,3 @@
-import { createCancellationToken } from "@jsenv/cancellation"
 import { findFreePort } from "@jsenv/server"
 import { createDetailedMessage } from "@jsenv/logger"
 
@@ -14,7 +13,7 @@ const AVAILABLE_DEBUG_MODE = [
 ]
 
 export const createChildProcessOptions = async ({
-  cancellationToken = createCancellationToken(),
+  signal = new AbortController().signal,
   // https://code.visualstudio.com/docs/nodejs/nodejs-debugging#_automatically-attach-debugger-to-nodejs-subprocesses
   processExecArgv = process.execArgv,
   processDebugPort = process.debugPort,
@@ -38,7 +37,7 @@ export const createChildProcessOptions = async ({
   const childProcessOptions = processOptionsFromExecArgv(processExecArgv)
 
   await mutateDebuggingOptions(childProcessOptions, {
-    cancellationToken,
+    signal,
     processDebugPort,
     debugMode,
     debugPort,
@@ -52,7 +51,7 @@ const mutateDebuggingOptions = async (
   childProcessOptions,
   {
     // ensure multiline
-    cancellationToken,
+    signal,
     processDebugPort,
     debugMode,
     debugPort,
@@ -92,7 +91,7 @@ const mutateDebuggingOptions = async (
   // support assigning a child spawned without a specific port
   const childDebugPortOptionValue =
     debugPort === 0
-      ? await findFreePort(processDebugPort + 37, { cancellationToken })
+      ? await findFreePort(processDebugPort + 37, { signal })
       : debugPort
   // replace child debug port
   if (parentDebugPortOptionName) {

package/src/internal/node-launcher/createControllableNodeProcess.js

@@ -1,8 +1,5 @@
-/* eslint-disable import/max-dependencies */
-import { fork as forkChildProcess } from "node:child_process"
-
+import { fork } from "node:child_process"
 import { uneval } from "@jsenv/uneval"
-import { createCancellationToken } from "@jsenv/cancellation"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import {
   urlToFileSystemPath,
@@ -10,14 +7,17 @@ import {
   assertFilePresence,
 } from "@jsenv/filesystem"
 
+import { Abortable } from "@jsenv/core/src/abort/main.js"
+import { raceCallbacks } from "@jsenv/core/src/abort/callback_race.js"
+import { createSignal } from "@jsenv/core/src/signal/signal.js"
 import { nodeSupportsDynamicImport } from "../runtime/node-feature-detect/nodeSupportsDynamicImport.js"
 import { jsenvCoreDirectoryUrl } from "../jsenvCoreDirectoryUrl.js"
-import { require } from "../require.js"
 import { createChildProcessOptions } from "./createChildProcessOptions.js"
 import {
   processOptionsFromExecArgv,
   execArgvFromProcessOptions,
 } from "./processOptions.js"
+import { killProcessTree } from "./kill_process_tree.js"
 
 const nodeControllableFileUrl = resolveUrl(
   "./src/internal/node-launcher/nodeControllableFile.mjs",
@@ -40,7 +40,7 @@ const STOP_SIGNAL = "SIGKILL"
 const GRACEFUL_STOP_FAILED_SIGNAL = "SIGKILL"
 
 export const createControllableNodeProcess = async ({
-  cancellationToken = createCancellationToken(),
+  signal = new AbortController().signal,
   logLevel,
   debugPort,
   debugMode,
@@ -61,7 +61,7 @@ export const createControllableNodeProcess = async ({
   }
 
   const childProcessOptions = await createChildProcessOptions({
-    cancellationToken,
+    signal,
     debugPort,
     debugMode,
     debugModeInheritBreak,
@@ -81,22 +81,19 @@ export const createControllableNodeProcess = async ({
     ...(inheritProcessEnv ? process.env : {}),
     ...env,
   }
-  const childProcess = forkChildProcess(
-    urlToFileSystemPath(nodeControllableFileUrl),
-    {
-      execArgv,
-      // silent: true
-      stdio: ["pipe", "pipe", "pipe", "ipc"],
-      env: envForChildProcess,
-    },
-  )
+  const childProcess = fork(urlToFileSystemPath(nodeControllableFileUrl), {
+    execArgv,
+    // silent: true
+    stdio: ["pipe", "pipe", "pipe", "ipc"],
+    env: envForChildProcess,
+  })
 
-  logger.debug(`fork child process pid ${childProcess.pid}
---- execArgv ---
-${execArgv.join(`
-`)}
---- custom env ---
-${JSON.stringify(env, null, "  ")}`)
+  logger.debug(
+    createDetailedMessage(`fork child process pid ${childProcess.pid}`, {
+      "execArgv": execArgv.join(`\n`),
+      "custom env": JSON.stringify(env, null, "  "),
+    }),
+  )
 
   // if we passe stream, pipe them https://github.com/sindresorhus/execa/issues/81
   if (typeof stdin === "object") {
@@ -120,199 +117,121 @@ ${JSON.stringify(env, null, "  ")}`)
     onceProcessMessage(childProcess, "ready", resolve)
   })
 
-  const consoleCallbackArray = []
-  const registerConsoleCallback = (callback) => {
-    consoleCallbackArray.push(callback)
-  }
+  const outputSignal = createSignal()
   const removeOutputListener = installProcessOutputListener(
     childProcess,
     ({ type, text }) => {
-      consoleCallbackArray.forEach((callback) => {
-        callback({
-          type,
-          text,
-        })
-      })
-    },
-  )
-  // keep listening process outputs while child process is killed to catch
-  // outputs until it's actually disconnected
-  // registerCleanupCallback(removeProcessOutputListener)
-
-  const errorCallbackArray = []
-  const registerErrorCallback = (callback) => {
-    errorCallbackArray.push(callback)
-    return () => {
-      const index = errorCallbackArray.indexOf(callback)
-      if (index > -1) {
-        errorCallbackArray.splice(index, 1)
-      }
-    }
-  }
-  let killing = false
-  const removeErrorListener = installProcessErrorListener(
-    childProcess,
-    (error) => {
-      removeOutputListener()
-      if (!childProcess.connected && error.code === "ERR_IPC_DISCONNECTED") {
-        return
-      }
-      // on windows killProcessTree uses taskkill which seems to kill the process
-      // with an exitCode of 1
-      if (process.platform === "win32" && killing && error.exitCode === 1) {
-        return
-      }
-      errorCallbackArray.forEach((callback) => {
-        callback(error)
-      })
+      outputSignal.emit({ type, text })
     },
   )
-  // keep listening process errors while child process is killed to catch
-  // errors until it's actually disconnected
-  // registerCleanupCallback(removeProcessErrorListener)
-
-  // https://nodejs.org/api/child_process.html#child_process_event_disconnect
-  let resolveDisconnect
-  let hasExitedOrDisconnected = false
-  const disconnected = new Promise((resolve) => {
-    resolveDisconnect = () => {
-      hasExitedOrDisconnected = true
-      removeExitListener()
-      removeDisconnectListener()
-    }
 
-    const removeDisconnectListener = onceProcessEvent(
-      childProcess,
-      "disconnect",
-      () => {
-        hasExitedOrDisconnected = true
-        removeErrorListener()
-        removeExitListener()
-        resolve()
-      },
-    )
+  const errorSignal = createSignal()
 
-    const removeExitListener = onceProcessEvent(childProcess, "exit", () => {
-      hasExitedOrDisconnected = true
-      removeErrorListener()
-      removeDisconnectListener()
-      resolve()
-    })
+  const stoppedSignal = createSignal({
+    once: true,
   })
-
-  const disconnectChildProcess = async () => {
-    if (hasExitedOrDisconnected) {
-      return
-    }
-    try {
-      childProcess.disconnect()
-    } catch (e) {
-      if (e.code === "ERR_IPC_DISCONNECTED") {
-        resolveDisconnect()
-      } else {
-        throw e
-      }
-    }
-    await disconnected
-  }
-
-  const killChildProcess = async ({ signal }) => {
-    if (hasExitedOrDisconnected) {
-      await disconnectChildProcess()
-      return
-    }
-
-    killing = true
-    logger.debug(`send ${signal} to child process with pid ${childProcess.pid}`)
-
-    await new Promise((resolve) => {
-      // see also https://github.com/sindresorhus/execa/issues/96
-      const killProcessTree = require("tree-kill")
-      killProcessTree(childProcess.pid, signal, (error) => {
-        if (error) {
-          // on windows: process with pid cannot be found
-          if (
-            error.stack.includes(`The process "${childProcess.pid}" not found`)
-          ) {
-            resolve()
-            return
-          }
-          // on windows: child process with a pid cannot be found
+  raceCallbacks(
+    {
+      // https://nodejs.org/api/child_process.html#child_process_event_disconnect
+      // disconnect: (cb) => {
+      //   return onceProcessEvent(childProcess, "disconnect", cb)
+      // },
+      // https://nodejs.org/api/child_process.html#child_process_event_error
+      error: (cb) => {
+        return onceProcessEvent(childProcess, "error", cb)
+      },
+      exit: (cb) => {
+        return onceProcessEvent(childProcess, "exit", (code, signal) => {
+          cb({ code, signal })
+        })
+      },
+    },
+    (winner) => {
+      const raceEffects = {
+        // disconnect: () => {
+        //   stoppedSignal.emit()
+        // },
+        error: (error) => {
+          removeOutputListener()
           if (
-            error.stack.includes(
-              "Reason: There is no running instance of the task",
-            )
+            !childProcess.connected &&
+            error.code === "ERR_IPC_DISCONNECTED"
           ) {
-            resolve()
             return
           }
-          // windows too
+          errorSignal.emit(error)
+        },
+        exit: ({ code, signal }) => {
+          // process.exit(1) in child process or process.exitCode = 1 + process.exit()
+          // means there was an error even if we don't know exactly what.
           if (
-            error.stack.includes("The operation attempted is not supported")
+            code !== null &&
+            code !== 0 &&
+            code !== SIGINT_EXIT_CODE &&
+            code !== SIGTERM_EXIT_CODE &&
+            code !== SIGABORT_EXIT_CODE
           ) {
-            resolve()
-            return
+            errorSignal.emit(createExitWithFailureCodeError(code))
           }
+          stoppedSignal.emit({ code, signal })
+        },
+      }
+      raceEffects[winner.name](winner.data)
+    },
+  )
 
-          logger.warn(
-            createDetailedMessage(
-              `error while killing process tree with ${signal}`,
-              {
-                ["error stack"]: error.stack,
-                ["process.pid"]: childProcess.pid,
-              },
-            ),
-          )
-
-          // even if we could not kill the child
-          // we will ask it to disconnect
-          resolve()
-          return
-        }
+  const stop = async ({ gracefulStopAllocatedMs } = {}) => {
+    if (stoppedSignal.emitted) {
+      return {}
+    }
 
-        resolve()
-      })
-    })
+    const createStoppedPromise = async () => {
+      if (stoppedSignal.emitted) {
+        return
+      }
+      await new Promise((resolve) => stoppedSignal.addCallback(resolve))
+    }
 
-    // in case the child process did not disconnect by itself at this point
-    // something is keeping it alive and it cannot be propely killed.
-    // wait for the child process to disconnect by itself
-    await disconnectChildProcess()
-  }
+    if (gracefulStopAllocatedMs) {
+      try {
+        await killProcessTree(childProcess.pid, {
+          signal: GRACEFUL_STOP_SIGNAL,
+          timeout: gracefulStopAllocatedMs,
+        })
+        await createStoppedPromise()
+        return { graceful: true }
+      } catch (e) {
+        if (e.code === "TIMEOUT") {
+          logger.debug(
+            `kill with SIGTERM because gracefulStop still pending after ${gracefulStopAllocatedMs}ms`,
+          )
+          await killProcessTree(childProcess.pid, {
+            signal: GRACEFUL_STOP_FAILED_SIGNAL,
+          })
+          await createStoppedPromise()
+          return { graceful: false }
+        }
+        throw e
+      }
+    }
 
-  const stop = async ({ gracefulFailed } = {}) => {
-    let unregisterErrorCallback
-    await Promise.race([
-      new Promise((resolve, reject) => {
-        unregisterErrorCallback = registerErrorCallback(reject)
-      }),
-      killChildProcess({
-        signal: gracefulFailed ? GRACEFUL_STOP_FAILED_SIGNAL : STOP_SIGNAL,
-      }),
-    ])
-    unregisterErrorCallback()
+    await killProcessTree(childProcess.pid, { signal: STOP_SIGNAL })
+    await createStoppedPromise()
+    return { graceful: false }
   }
 
-  const gracefulStop = async () => {
-    let unregisterErrorCallback
-    await Promise.race([
-      new Promise((resolve, reject) => {
-        unregisterErrorCallback = registerErrorCallback(reject)
-      }),
-      killChildProcess({ signal: GRACEFUL_STOP_SIGNAL }),
-    ])
-    unregisterErrorCallback()
-  }
+  const requestActionOnChildProcess = ({
+    signal,
+    actionType,
+    actionParams,
+  }) => {
+    const actionAbortable = Abortable.fromSignal(signal)
 
-  const requestActionOnChildProcess = ({ actionType, actionParams }) => {
     return new Promise(async (resolve, reject) => {
+      Abortable.throwIfAborted(actionAbortable)
+      await childProcessReadyPromise
+
       onceProcessMessage(childProcess, "action-result", ({ status, value }) => {
-        logger.debug(
-          createDetailedMessage(`child process sent an action result.`, {
-            status,
-            value: JSON.stringify(value, null, "  "),
-          }),
-        )
         if (status === "action-completed") {
           resolve(value)
         } else {
@@ -327,13 +246,16 @@ ${JSON.stringify(env, null, "  ")}`)
         }),
       )
 
-      await childProcessReadyPromise
       try {
+        Abortable.throwIfAborted(actionAbortable)
         await sendToProcess(childProcess, "action", {
           actionType,
           actionParams,
         })
       } catch (e) {
+        if (actionAbortable.signal.aborted && e.name === "AbortError") {
+          throw e
+        }
         logger.error(
           createDetailedMessage(`error while sending message to child`, {
             ["error stack"]: e.stack,
@@ -346,15 +268,11 @@ ${JSON.stringify(env, null, "  ")}`)
 
   return {
     execArgv,
-    gracefulStop,
+    stoppedSignal,
+    errorSignal,
+    outputSignal,
     stop,
-    disconnected,
-    registerErrorCallback,
-    registerConsoleCallback,
     requestActionOnChildProcess,
-    onceChildProcessEvent: (event, callback) => {
-      onceProcessEvent(childProcess, event, callback)
-    },
   }
 }
 
@@ -390,36 +308,6 @@ const installProcessOutputListener = (childProcess, callback) => {
   }
 }
 
-const installProcessErrorListener = (childProcess, callback) => {
-  // https://nodejs.org/api/child_process.html#child_process_event_error
-  const removeErrorListener = onceProcessMessage(
-    childProcess,
-    "error",
-    (error) => {
-      removeExitListener() // if an error occured we ignore the child process exitCode
-      callback(error)
-    },
-  )
-  // process.exit(1) in child process or process.exitCode = 1 + process.exit()
-  // means there was an error even if we don't know exactly what.
-  const removeExitListener = onceProcessEvent(childProcess, "exit", (code) => {
-    if (
-      code !== null &&
-      code !== 0 &&
-      code !== SIGINT_EXIT_CODE &&
-      code !== SIGTERM_EXIT_CODE &&
-      code !== SIGABORT_EXIT_CODE
-    ) {
-      removeErrorListener()
-      callback(createExitWithFailureCodeError(code))
-    }
-  })
-  return () => {
-    removeErrorListener()
-    removeExitListener()
-  }
-}
-
 const createExitWithFailureCodeError = (code) => {
   if (code === 12) {
     return new Error(

package/src/internal/node-launcher/kill_process_tree.js

@@ -0,0 +1,76 @@
+import { require } from "../require.js"
+
+// see also https://github.com/sindresorhus/execa/issues/96
+export const killProcessTree = async (
+  processId,
+  { signal, timeout = 2000 },
+) => {
+  var pidtree = require("pidtree")
+
+  let descendantProcessIds
+  try {
+    descendantProcessIds = await pidtree(processId)
+  } catch (e) {
+    if (e.message === "No matching pid found") {
+      descendantProcessIds = []
+    } else {
+      throw e
+    }
+  }
+  descendantProcessIds.forEach((descendantProcessId) => {
+    try {
+      process.kill(descendantProcessId, signal)
+    } catch (error) {
+      // ignore
+    }
+  })
+
+  try {
+    process.kill(processId, signal)
+  } catch (e) {
+    if (e.code !== "ESRCH") {
+      throw e
+    }
+  }
+
+  let remainingIds = [...descendantProcessIds, processId]
+
+  const updateRemainingIds = () => {
+    remainingIds = remainingIds.filter((remainingId) => {
+      try {
+        process.kill(remainingId, 0)
+        return true
+      } catch (e) {
+        return false
+      }
+    })
+  }
+
+  let timeSpentWaiting = 0
+
+  const check = async () => {
+    updateRemainingIds()
+    if (remainingIds.length === 0) {
+      return
+    }
+
+    if (timeSpentWaiting > timeout) {
+      const timeoutError = new Error(
+        `timed out waiting for ${
+          remainingIds.length
+        } process to exit (${remainingIds.join(" ")})`,
+      )
+      timeoutError.code = "TIMEOUT"
+      throw timeoutError
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 400))
+    timeSpentWaiting += 400
+    await check()
+  }
+
+  await new Promise((resolve) => {
+    setTimeout(resolve, 0)
+  })
+  await check()
+}

package/src/internal/node-launcher/nodeControllableFile.mjs

@@ -1,3 +1,4 @@
+import v8 from "node:v8"
 import { uneval } from "@jsenv/uneval"
 
 import { jsenvNodeSystemFileInfo } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
@@ -116,13 +117,6 @@ const onceProcessMessage = (type, callback) => {
   return removeListener
 }
 
-const onceSIGTERM = (callback) => {
-  process.once("SIGTERM", callback)
-  return () => {
-    process.removeListener("SIGTERM", callback)
-  }
-}
-
 const removeActionRequestListener = onceProcessMessage(
   ACTION_REQUEST_EVENT_NAME,
   async ({ actionType, actionParams }) => {
@@ -141,6 +135,15 @@ const removeActionRequestListener = onceProcessMessage(
       value = e
     }
 
+    if (process.env.NODE_V8_COVERAGE) {
+      v8.takeCoverage()
+      // if (actionParams.stopCoverageAfterExecution) {
+      //   v8.stopCoverage()
+      // }
+    }
+
+    // setTimeout(() => {}, 100)
+
     if (failed) {
       sendActionFailed(value)
     } else {
@@ -149,8 +152,10 @@ const removeActionRequestListener = onceProcessMessage(
 
     // removeActionRequestListener()
     if (actionParams.exitAfterAction) {
-      // for some reason this fixes v8 coverage directory somtimes empty
-      process.exit()
+      removeActionRequestListener()
+
+      // for some reason this fixes v8 coverage directory sometimes empty on Ubuntu
+      // process.exit()
     }
   },
 )
@@ -158,6 +163,7 @@ const removeActionRequestListener = onceProcessMessage(
 // remove listener to process.on('message')
 // which is sufficient to let child process die
 // assuming nothing else keeps it alive
-onceSIGTERM(removeActionRequestListener)
+// process.once("SIGTERM", removeActionRequestListener)
+// process.once("SIGINT", removeActionRequestListener)
 
 setTimeout(() => sendToParent("ready"))

package/src/internal/{promise_track_race.js → promise_race.js}

@@ -1,4 +1,4 @@
-export const promiseTrackRace = (promiseArray) => {
+export const racePromises = (promiseArray) => {
   return new Promise((resolve, reject) => {
     let resolved = false
 
@@ -7,7 +7,7 @@ export const promiseTrackRace = (promiseArray) => {
       promise.then((value) => {
         if (resolved) return
         resolved = true
-        resolve({ winner: promise, value, index })
+        resolve({ promise, value, index })
       }, reject)
     }