@jsenv/core 23.2.2 → 23.4.2

package/src/internal/executing/launchAndExecute.js

@@ -1,12 +1,9 @@
+import cuid from "cuid"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
+import { Abort, raceCallbacks } from "@jsenv/abort"
+import { resolveUrl, writeFile } from "@jsenv/filesystem"
 
-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"
+import { composeTwoFileByFileIstanbulCoverages } from "./coverage_utils/istanbul_coverage_composition.js"
 
 export const launchAndExecute = async ({
   signal = new AbortController().signal,
@@ -24,6 +21,7 @@ export const launchAndExecute = async ({
   collectRuntimeVersion = false,
   inheritCoverage = false,
   collectCoverage = false,
+  coverageTempDirectoryUrl,
   measurePerformance,
   collectPerformance = false,
 
@@ -32,7 +30,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,
@@ -44,8 +42,6 @@ export const launchAndExecute = async ({
     // by default throw on error after execution
     throw error
   },
-
-  coverageV8MergeConflictIsExpected,
 } = {}) => {
   const logger = createLogger({ logLevel: launchAndExecuteLogLevel })
 
@@ -60,27 +56,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) {
@@ -143,40 +132,61 @@ export const launchAndExecute = async ({
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
       (executionResult) => {
-        const { coverage, ...rest } = executionResult
-        // ensure the coverage of the executed file is taken into account
-        global.__coverage__ = composeIstanbulCoverages([
+        const { coverage } = executionResult
+        // propagate coverage from execution to this process
+        global.__coverage__ = composeTwoFileByFileIstanbulCoverages(
           global.__coverage__ || {},
           coverage || {},
-        ])
-        if (collectCoverageSaved) {
-          return executionResult
+        )
+
+        if (!collectCoverageSaved) {
+          delete executionResult.coverage
         }
-        return rest
+
+        return executionResult
       },
     )
   }
 
-  // indirectCoverage is a feature making possible to collect
-  // coverage generated by executing a node process which executes
-  // a browser. The coverage coming the browser executionwould be lost
-  // if not propagated somehow.
-  // This is possible if the node process collect the browser coverage
-  // and write it into global.__indirectCoverage__
-  // This is used by jsenv during tests execution
   if (collectCoverage) {
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
-      (executionResult) => {
-        const { coverage = {}, indirectCoverage } = executionResult
+      async (executionResult) => {
+        // we do not keep coverage in memory, it can grow very big
+        // instead we store it on the filesystem, they will be read and merged together later on
+        // in "executeConcurrently"
+        const { coverage } = executionResult
+        if (coverage) {
+          const coverageFileUrl = resolveUrl(
+            `./${runtime.name}/${cuid()}`,
+            coverageTempDirectoryUrl,
+          )
+          await writeFile(coverageFileUrl, JSON.stringify(coverage, null, "  "))
+          executionResult.coverageFileUrl = coverageFileUrl
+          delete executionResult.coverage
+        }
+
+        // indirectCoverage is a feature making possible to collect
+        // coverage generated by executing a node process which executes
+        // a browser. The coverage coming the browser execution would be lost
+        // if not propagated somehow.
+        // This is possible if the node process collect the browser coverage
+        // and write it into global.__indirectCoverage__
+        // This is used by jsenv during tests execution
+        const { indirectCoverage } = executionResult
         if (indirectCoverage) {
-          executionResult.coverage = composeIstanbulCoverages(
-            [coverage, indirectCoverage],
-            {
-              coverageV8MergeConflictIsExpected,
-            },
+          const indirectCoverageFileUrl = resolveUrl(
+            `./${runtime.name}/${cuid()}`,
+            coverageTempDirectoryUrl,
+          )
+          await writeFile(
+            indirectCoverageFileUrl,
+            JSON.stringify(indirectCoverage, null, "  "),
           )
+          executionResult.indirectCoverageFileUrl = indirectCoverageFileUrl
+          delete executionResult.indirectCoverage
         }
+
         return executionResult
       },
     )
@@ -188,31 +198,12 @@ export const launchAndExecute = async ({
         // executionResult.coverage is undefined or {}
         // we delete it just to have a cleaner object
         delete executionResult.coverage
+        delete executionResult.indirectCoverage
         return executionResult
       },
     )
   }
 
-  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 +221,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 +231,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 +251,9 @@ export const launchAndExecute = async ({
 
     logger.debug(`${runtimeLabel}: start execution`)
     const {
-      errorSignal,
-      outputSignal,
-      stoppedSignal,
+      errorCallbackList,
+      outputCallbackList,
+      stoppedCallbackList,
       execute,
       finalizeExecutionResult = (executionResult) => executionResult,
     } = launchReturnValue
@@ -265,104 +261,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 +322,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 +443,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,
   }