@jsenv/core 23.2.2 → 23.3.0

package/src/internal/executing/launchAndExecute.js

@@ -1,13 +1,8 @@
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
+import { Abort, raceCallbacks } from "@jsenv/abort"
 
-import { Abortable } from "@jsenv/core/src/abort/main.js"
-import { raceCallbacks } from "../../abort/callback_race.js"
 import { composeIstanbulCoverages } from "./coverage/composeIstanbulCoverages.js"
 
-const TIMING_BEFORE_EXECUTION = "before-execution"
-const TIMING_DURING_EXECUTION = "during-execution"
-const TIMING_AFTER_EXECUTION = "after-execution"
-
 export const launchAndExecute = async ({
   signal = new AbortController().signal,
   launchAndExecuteLogLevel,
@@ -32,7 +27,7 @@ export const launchAndExecute = async ({
   // however unit test will pass true because they want to move on
   stopAfterExecute = false,
   stopAfterExecuteReason = "stop after execute",
-  // when launch returns { stoppedSignal, gracefulStop, stop }
+  // when launch returns { stoppedCallbackList, gracefulStop, stop }
   // the launched runtime have that amount of ms for disconnected to resolve
   // before we call stop
   gracefulStopAllocatedMs = 4000,
@@ -60,27 +55,20 @@ export const launchAndExecute = async ({
 
   let executionResultTransformer = (executionResult) => executionResult
 
-  const launchAndExecuteOperation = Abortable.fromSignal(signal)
+  const launchAndExecuteOperation = Abort.startOperation()
+  launchAndExecuteOperation.addAbortSignal(signal)
 
   const hasAllocatedMs =
     typeof allocatedMs === "number" && allocatedMs !== Infinity
-  let timeoutAbortEffect
+  let timeoutAbortSource
 
   if (hasAllocatedMs) {
-    timeoutAbortEffect = Abortable.timeout(
-      launchAndExecuteOperation,
+    timeoutAbortSource = launchAndExecuteOperation.timeout(
       // FIXME: if allocatedMs is veryyyyyy big
       // setTimeout may be called immediatly
       // in that case we should just throw that the number is too big
       allocatedMs,
     )
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        timeoutAbortEffect.cleanup()
-        return executionResult
-      },
-    )
   }
 
   if (mirrorConsole) {
@@ -193,26 +181,6 @@ export const launchAndExecute = async ({
     )
   }
 
-  if (stopAfterExecute) {
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      async (executionResult) => {
-        // if there is an error while cleaning (stopping the runtime)
-        // the execution is considered as failed
-        try {
-          await launchAndExecuteOperation.cleaner.clean(stopAfterExecuteReason)
-          return executionResult
-        } catch (e) {
-          return executionResultTransformer(
-            createErroredExecutionResult({
-              error: e,
-            }),
-          )
-        }
-      },
-    )
-  }
-
   if (measureDuration) {
     const startMs = Date.now()
     executionResultTransformer = composeTransformer(
@@ -230,7 +198,7 @@ export const launchAndExecute = async ({
     const runtimeLabel = `${runtime.name}/${runtime.version}`
     logger.debug(`launch ${runtimeLabel} to execute something in it`)
 
-    Abortable.throwIfAborted(launchAndExecuteOperation)
+    launchAndExecuteOperation.throwIfAborted()
     const launchReturnValue = await runtime.launch({
       signal: launchAndExecuteOperation.signal,
       logger,
@@ -240,14 +208,19 @@ export const launchAndExecute = async ({
       ...runtimeParams,
     })
     validateLaunchReturnValue(launchReturnValue)
-    launchAndExecuteOperation.cleaner.addCallback(async (reason) => {
-      await stopRuntime({
-        logger,
-        runtimeLabel,
-        launchReturnValue,
-        gracefulStopAllocatedMs,
-        reason,
-      })
+
+    const stopRuntime = async (reason) => {
+      const { stop } = launchReturnValue
+      logger.debug(`${runtimeLabel}: stop() because ${reason}`)
+      const { graceful } = await stop({ reason, gracefulStopAllocatedMs })
+      if (graceful) {
+        logger.debug(`${runtimeLabel}: runtime stopped gracefully`)
+      } else {
+        logger.debug(`${runtimeLabel}: runtime stopped`)
+      }
+    }
+    launchAndExecuteOperation.addAbortCallback(async () => {
+      await stopRuntime("Operation aborted")
     })
 
     logger.debug(createDetailedMessage(`${runtimeLabel}: runtime launched`))
@@ -255,9 +228,9 @@ export const launchAndExecute = async ({
 
     logger.debug(`${runtimeLabel}: start execution`)
     const {
-      errorSignal,
-      outputSignal,
-      stoppedSignal,
+      errorCallbackList,
+      outputCallbackList,
+      stoppedCallbackList,
       execute,
       finalizeExecutionResult = (executionResult) => executionResult,
     } = launchReturnValue
@@ -265,104 +238,60 @@ export const launchAndExecute = async ({
       executionResultTransformer,
       finalizeExecutionResult,
     )
-    outputSignal.addCallback(runtimeConsoleCallback)
-
-    let timing = TIMING_BEFORE_EXECUTION
-    stoppedSignal.addCallback(() => {
-      logger.debug(`${runtimeLabel}: runtime stopped ${timing}`)
-      runtimeStoppedCallback()
-    })
+    outputCallbackList.add(runtimeConsoleCallback)
 
-    const winnerPromise = new Promise((resolve, reject) => {
-      raceCallbacks(
-        {
-          aborted: (cb) => {
-            launchAndExecuteOperation.signal.addEventListener("abort", cb)
-            return () => {
-              launchAndExecuteOperation.signal.removeEventListener("abort", cb)
-            }
-          },
-          error: (cb) => {
-            return errorSignal.addCallback(cb)
-          },
-          stopped: (cb) => {
-            return stoppedSignal.addCallback(cb)
-          },
-          executed: (cb) => {
-            timing = TIMING_DURING_EXECUTION
-            const executed = execute({
-              signal: launchAndExecuteOperation.signal,
-              ...executeParams,
-            })
-            executed.then(cb, reject)
-          },
-        },
-        resolve,
-      )
+    let executionResult = await callExecute({
+      launchAndExecuteOperation,
+      errorCallbackList,
+      stoppedCallbackList,
+      execute,
+      executeParams,
     })
 
-    Abortable.throwIfAborted(launchAndExecuteOperation)
-
-    const winner = await winnerPromise
-
-    if (winner.name === "aborted") {
-      Abortable.throwIfAborted(launchAndExecuteOperation)
-    }
-
-    if (winner.name === "error") {
-      return executionResultTransformer(
-        createErroredExecutionResult({
-          error: winner.data,
-        }),
-      )
-    }
-
-    if (winner.name === "stopped") {
-      return executionResultTransformer(
-        createErroredExecutionResult({
-          error: new Error(`runtime stopped during execution`),
-        }),
-      )
-    }
-
-    timing = TIMING_AFTER_EXECUTION
-
-    if (!stopAfterExecute) {
+    if (stopAfterExecute) {
+      // stopping runtime is part of the execution
+      try {
+        await stopRuntime(stopAfterExecuteReason)
+      } catch (e) {
+        executionResult = createErroredExecutionResult({
+          error: e,
+        })
+      }
+    } else {
       // when the process is still alive
       // we want to catch error to notify runtimeErrorAfterExecutionCallback
       // and throw that error by default
-      errorSignal.addCallback((error) => {
+      errorCallbackList.add((error) => {
         runtimeErrorAfterExecutionCallback(error)
       })
+      stoppedCallbackList.add(() => {
+        logger.debug(`${runtimeLabel}: runtime stopped after execution`)
+        runtimeStoppedCallback()
+      })
     }
 
-    const executeResult = winner.data
-    const { status } = executeResult
-
-    if (status === "errored") {
+    if (executionResult.status === "errored") {
       // debug log level because this error happens during execution
       // there is no need to log it.
       // the code will know the execution errored because it receives
       // an errored execution result
       logger.debug(
-        createDetailedMessage(`error ${TIMING_DURING_EXECUTION}`, {
-          ["error stack"]: executeResult.error.stack,
+        createDetailedMessage(`error during execution`, {
+          ["error stack"]: executionResult.error.stack,
           ["execute params"]: JSON.stringify(executeParams, null, "  "),
           ["runtime"]: runtime,
         }),
       )
-      return executionResultTransformer(
-        createErroredExecutionResult(executeResult),
-      )
+    } else {
+      logger.debug(`${runtimeLabel}: execution ${executionResult.status}`)
     }
 
-    logger.debug(`${runtimeLabel}: execution completed`)
-    return executionResultTransformer(
-      createCompletedExecutionResult(executeResult),
-    )
+    return executionResultTransformer(executionResult)
   } catch (e) {
-    if (e.name === "AbortError") {
-      if (timeoutAbortEffect && timeoutAbortEffect.signal.aborted) {
+    if (Abort.isAbortError(e)) {
+      // we should stop runtime too
+
+      if (timeoutAbortSource && timeoutAbortSource.signal.aborted) {
         const executionResult = createTimedoutExecutionResult()
         return executionResultTransformer(executionResult)
       }
@@ -370,24 +299,71 @@ export const launchAndExecute = async ({
       return executionResultTransformer(executionResult)
     }
     throw e
+  } finally {
+    await launchAndExecuteOperation.end()
   }
 }
 
-const stopRuntime = async ({
-  logger,
-  runtimeLabel,
-  launchReturnValue,
-  gracefulStopAllocatedMs,
-  reason,
+const callExecute = async ({
+  launchAndExecuteOperation,
+  errorCallbackList,
+  stoppedCallbackList,
+  execute,
+  executeParams,
 }) => {
-  const { stop } = launchReturnValue
-  logger.debug(`${runtimeLabel}: stop() because ${reason}`)
-  const { graceful } = await stop({ reason, gracefulStopAllocatedMs })
-  if (graceful) {
-    logger.debug(`${runtimeLabel}: runtime stopped gracefully`)
-  } else {
-    logger.debug(`${runtimeLabel}: runtime stopped`)
+  const winnerPromise = new Promise((resolve, reject) => {
+    raceCallbacks(
+      {
+        aborted: (cb) => {
+          launchAndExecuteOperation.signal.addEventListener("abort", cb)
+          return () => {
+            launchAndExecuteOperation.signal.removeEventListener("abort", cb)
+          }
+        },
+        error: (cb) => {
+          return errorCallbackList.add(cb)
+        },
+        stopped: (cb) => {
+          return stoppedCallbackList.add(cb)
+        },
+        executed: (cb) => {
+          const executed = execute({
+            signal: launchAndExecuteOperation.signal,
+            ...executeParams,
+          })
+          executed.then(cb, reject)
+        },
+      },
+      resolve,
+    )
+  })
+
+  launchAndExecuteOperation.throwIfAborted()
+  const winner = await winnerPromise
+
+  if (winner.name === "aborted") {
+    launchAndExecuteOperation.throwIfAborted()
   }
+
+  if (winner.name === "error") {
+    return createErroredExecutionResult({
+      error: winner.data,
+    })
+  }
+
+  if (winner.name === "stopped") {
+    return createErroredExecutionResult({
+      error: new Error(`runtime stopped during execution`),
+    })
+  }
+
+  const executeResult = winner.data
+  const { status } = executeResult
+
+  if (status === "errored") {
+    return createErroredExecutionResult(executeResult)
+  }
+  return createCompletedExecutionResult(executeResult)
 }
 
 const createAbortedExecutionResult = () => {
@@ -444,22 +420,26 @@ const composeTransformer = (previousTransformer, transformer) => {
 
 const validateLaunchReturnValue = (launchReturnValue) => {
   if (launchReturnValue === null) {
-    throw new Error(`launch must return an object, got null`)
+    throw new Error(`runtime.launch must return an object, got null`)
   }
 
   if (typeof launchReturnValue !== "object") {
-    throw new Error(`launch must return an object, got ${launchReturnValue}`)
+    throw new Error(
+      `runtime.launch must return an object, got ${launchReturnValue}`,
+    )
   }
 
   const { execute } = launchReturnValue
   if (typeof execute !== "function") {
-    throw new Error(`launch must return an execute function, got ${execute}`)
+    throw new Error(
+      `runtime.launch must return an execute function, got ${execute}`,
+    )
   }
 
-  const { stoppedSignal } = launchReturnValue
-  if (!stoppedSignal) {
+  const { stoppedCallbackList } = launchReturnValue
+  if (!stoppedCallbackList) {
     throw new Error(
-      `launch must return a stoppedSignal object, got ${stoppedSignal}`,
+      `runtime.launch must return a stoppedCallbackList object, got ${stoppedCallbackList}`,
     )
   }
 }

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

@@ -6,10 +6,13 @@ import {
   resolveUrl,
   assertFilePresence,
 } from "@jsenv/filesystem"
+import {
+  Abort,
+  raceCallbacks,
+  createCallbackList,
+  createCallbackListNotifiedOnce,
+} from "@jsenv/abort"
 
-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 { createChildProcessOptions } from "./createChildProcessOptions.js"
@@ -117,19 +120,18 @@ export const createControllableNodeProcess = async ({
     onceProcessMessage(childProcess, "ready", resolve)
   })
 
-  const outputSignal = createSignal()
+  const outputCallbackList = createCallbackList()
   const removeOutputListener = installProcessOutputListener(
     childProcess,
     ({ type, text }) => {
-      outputSignal.emit({ type, text })
+      outputCallbackList.notify({ type, text })
     },
   )
 
-  const errorSignal = createSignal()
+  const errorCallbackList = createCallbackList()
+
+  const stoppedCallbackList = createCallbackListNotifiedOnce()
 
-  const stoppedSignal = createSignal({
-    once: true,
-  })
   raceCallbacks(
     {
       // https://nodejs.org/api/child_process.html#child_process_event_disconnect
@@ -149,7 +151,7 @@ export const createControllableNodeProcess = async ({
     (winner) => {
       const raceEffects = {
         // disconnect: () => {
-        //   stoppedSignal.emit()
+        //   stoppedCallbackList.notify()
         // },
         error: (error) => {
           removeOutputListener()
@@ -159,7 +161,7 @@ export const createControllableNodeProcess = async ({
           ) {
             return
           }
-          errorSignal.emit(error)
+          errorCallbackList.notify(error)
         },
         exit: ({ code, signal }) => {
           // process.exit(1) in child process or process.exitCode = 1 + process.exit()
@@ -171,9 +173,9 @@ export const createControllableNodeProcess = async ({
             code !== SIGTERM_EXIT_CODE &&
             code !== SIGABORT_EXIT_CODE
           ) {
-            errorSignal.emit(createExitWithFailureCodeError(code))
+            errorCallbackList.notify(createExitWithFailureCodeError(code))
           }
-          stoppedSignal.emit({ code, signal })
+          stoppedCallbackList.notify({ code, signal })
         },
       }
       raceEffects[winner.name](winner.data)
@@ -181,15 +183,15 @@ export const createControllableNodeProcess = async ({
   )
 
   const stop = async ({ gracefulStopAllocatedMs } = {}) => {
-    if (stoppedSignal.emitted) {
+    if (stoppedCallbackList.notified) {
       return {}
     }
 
     const createStoppedPromise = async () => {
-      if (stoppedSignal.emitted) {
+      if (stoppedCallbackList.notified) {
         return
       }
-      await new Promise((resolve) => stoppedSignal.addCallback(resolve))
+      await new Promise((resolve) => stoppedCallbackList.add(resolve))
     }
 
     if (gracefulStopAllocatedMs) {
@@ -225,10 +227,11 @@ export const createControllableNodeProcess = async ({
     actionType,
     actionParams,
   }) => {
-    const actionAbortable = Abortable.fromSignal(signal)
+    const actionOperation = Abort.startOperation()
+    actionOperation.addAbortSignal(signal)
 
     return new Promise(async (resolve, reject) => {
-      Abortable.throwIfAborted(actionAbortable)
+      actionOperation.throwIfAborted()
       await childProcessReadyPromise
 
       onceProcessMessage(childProcess, "action-result", ({ status, value }) => {
@@ -247,13 +250,13 @@ export const createControllableNodeProcess = async ({
       )
 
       try {
-        Abortable.throwIfAborted(actionAbortable)
+        actionOperation.throwIfAborted()
         await sendToProcess(childProcess, "action", {
           actionType,
           actionParams,
         })
       } catch (e) {
-        if (actionAbortable.signal.aborted && e.name === "AbortError") {
+        if (Abort.isAbortError(e) && actionOperation.signal.aborted) {
           throw e
         }
         logger.error(
@@ -268,9 +271,9 @@ export const createControllableNodeProcess = async ({
 
   return {
     execArgv,
-    stoppedSignal,
-    errorSignal,
-    outputSignal,
+    stoppedCallbackList,
+    errorCallbackList,
+    outputCallbackList,
     stop,
     requestActionOnChildProcess,
   }