@jsenv/core 23.1.4 → 23.3.0

package/src/internal/executing/launchAndExecute.js

@@ -1,23 +1,11 @@
-import {
-  createCancellationToken,
-  createOperation,
-  createStoppableOperation,
-  createCancellationSource,
-  composeCancellationToken,
-  errorToCancelReason,
-} from "@jsenv/cancellation"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
+import { Abort, raceCallbacks } from "@jsenv/abort"
 
-import { promiseTrackRace } from "../promise_track_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,
-  cancellationToken = createCancellationToken(),
 
   runtime,
   runtimeParams,
@@ -39,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 { disconnected, 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,
@@ -51,7 +39,6 @@ export const launchAndExecute = async ({
     // by default throw on error after execution
     throw error
   },
-  runtimeDisconnectCallback = () => {},
 
   coverageV8MergeConflictIsExpected,
 } = {}) => {
@@ -68,16 +55,19 @@ export const launchAndExecute = async ({
 
   let executionResultTransformer = (executionResult) => executionResult
 
-  if (measureDuration) {
-    const startMs = Date.now()
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        const endMs = Date.now()
-        executionResult.startMs = startMs
-        executionResult.endMs = endMs
-        return executionResult
-      },
+  const launchAndExecuteOperation = Abort.startOperation()
+  launchAndExecuteOperation.addAbortSignal(signal)
+
+  const hasAllocatedMs =
+    typeof allocatedMs === "number" && allocatedMs !== Infinity
+  let timeoutAbortSource
+
+  if (hasAllocatedMs) {
+    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,
     )
   }
 
@@ -166,7 +156,7 @@ export const launchAndExecute = async ({
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
       (executionResult) => {
-        const { coverage, indirectCoverage } = executionResult
+        const { coverage = {}, indirectCoverage } = executionResult
         if (indirectCoverage) {
           executionResult.coverage = composeIstanbulCoverages(
             [coverage, indirectCoverage],
@@ -191,274 +181,200 @@ export const launchAndExecute = async ({
     )
   }
 
-  let executionResult
-  const executionParams = {
-    logger,
-    cancellationToken,
+  if (measureDuration) {
+    const startMs = Date.now()
+    executionResultTransformer = composeTransformer(
+      executionResultTransformer,
+      (executionResult) => {
+        const endMs = Date.now()
+        executionResult.startMs = startMs
+        executionResult.endMs = endMs
+        return executionResult
+      },
+    )
+  }
+
+  try {
+    const runtimeLabel = `${runtime.name}/${runtime.version}`
+    logger.debug(`launch ${runtimeLabel} to execute something in it`)
 
-    runtime,
-    runtimeParams: {
+    launchAndExecuteOperation.throwIfAborted()
+    const launchReturnValue = await runtime.launch({
+      signal: launchAndExecuteOperation.signal,
+      logger,
+      stopAfterExecute,
       measurePerformance,
       collectPerformance,
       ...runtimeParams,
-    },
-    executeParams,
-
-    stopAfterExecute,
-    stopAfterExecuteReason,
-    gracefulStopAllocatedMs,
-    runtimeConsoleCallback,
-    runtimeErrorAfterExecutionCallback,
-    runtimeDisconnectCallback,
-    runtimeStartedCallback,
-    runtimeStoppedCallback,
-  }
-  const hasAllocatedMs =
-    typeof allocatedMs === "number" && allocatedMs !== Infinity
-  if (hasAllocatedMs) {
-    const TIMEOUT_CANCEL_REASON = "timeout"
-
-    const timeoutCancellationSource = createCancellationSource()
-
-    const id = setTimeout(() => {
-      // here if allocatedMs is very big
-      // setTimeout may be called immediatly
-      // in that case we should just throw that hte number is too big
-      timeoutCancellationSource.cancel(TIMEOUT_CANCEL_REASON)
-    }, allocatedMs)
-    const timeoutCancel = () => clearTimeout(id)
-
-    cancellationToken.register(timeoutCancel)
-
-    const externalOrTimeoutCancellationToken = composeCancellationToken(
-      cancellationToken,
-      timeoutCancellationSource.token,
-    )
-
-    try {
-      executionResult = await computeExecutionResult({
-        ...executionParams,
-        cancellationToken: externalOrTimeoutCancellationToken,
-      })
-      timeoutCancel()
-    } catch (e) {
-      if (errorToCancelReason(e) === TIMEOUT_CANCEL_REASON) {
-        executionResult = createTimedoutExecutionResult()
+    })
+    validateLaunchReturnValue(launchReturnValue)
+
+    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 {
-        throw e
+        logger.debug(`${runtimeLabel}: runtime stopped`)
       }
     }
-  } else {
-    executionResult = await computeExecutionResult(executionParams)
-  }
+    launchAndExecuteOperation.addAbortCallback(async () => {
+      await stopRuntime("Operation aborted")
+    })
+
+    logger.debug(createDetailedMessage(`${runtimeLabel}: runtime launched`))
+    runtimeStartedCallback()
+
+    logger.debug(`${runtimeLabel}: start execution`)
+    const {
+      errorCallbackList,
+      outputCallbackList,
+      stoppedCallbackList,
+      execute,
+      finalizeExecutionResult = (executionResult) => executionResult,
+    } = launchReturnValue
+    executionResultTransformer = composeTransformer(
+      executionResultTransformer,
+      finalizeExecutionResult,
+    )
+    outputCallbackList.add(runtimeConsoleCallback)
+
+    let executionResult = await callExecute({
+      launchAndExecuteOperation,
+      errorCallbackList,
+      stoppedCallbackList,
+      execute,
+      executeParams,
+    })
+
+    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
+      errorCallbackList.add((error) => {
+        runtimeErrorAfterExecutionCallback(error)
+      })
+      stoppedCallbackList.add(() => {
+        logger.debug(`${runtimeLabel}: runtime stopped after execution`)
+        runtimeStoppedCallback()
+      })
+    }
 
-  return executionResultTransformer(executionResult)
-}
+    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 during execution`, {
+          ["error stack"]: executionResult.error.stack,
+          ["execute params"]: JSON.stringify(executeParams, null, "  "),
+          ["runtime"]: runtime,
+        }),
+      )
+    } else {
+      logger.debug(`${runtimeLabel}: execution ${executionResult.status}`)
+    }
 
-const composeCallback = (previousCallback, callback) => {
-  return (...args) => {
-    previousCallback(...args)
-    return callback(...args)
-  }
-}
+    return executionResultTransformer(executionResult)
+  } catch (e) {
+    if (Abort.isAbortError(e)) {
+      // we should stop runtime too
 
-const composeTransformer = (previousTransformer, transformer) => {
-  return (value) => {
-    const transformedValue = previousTransformer(value)
-    return transformer(transformedValue)
+      if (timeoutAbortSource && timeoutAbortSource.signal.aborted) {
+        const executionResult = createTimedoutExecutionResult()
+        return executionResultTransformer(executionResult)
+      }
+      const executionResult = createAbortedExecutionResult()
+      return executionResultTransformer(executionResult)
+    }
+    throw e
+  } finally {
+    await launchAndExecuteOperation.end()
   }
 }
 
-const computeExecutionResult = async ({
-  logger,
-  cancellationToken,
-
-  runtime,
-  runtimeParams,
+const callExecute = async ({
+  launchAndExecuteOperation,
+  errorCallbackList,
+  stoppedCallbackList,
+  execute,
   executeParams,
-
-  stopAfterExecute,
-  stopAfterExecuteReason,
-  gracefulStopAllocatedMs,
-  runtimeStartedCallback,
-  runtimeStoppedCallback,
-  runtimeConsoleCallback,
-  runtimeErrorAfterExecutionCallback,
-  runtimeDisconnectCallback,
 }) => {
-  const runtimeLabel = `${runtime.name}/${runtime.version}`
-
-  logger.debug(`launch ${runtimeLabel} to execute something in it`)
-
-  const launchOperation = createStoppableOperation({
-    cancellationToken,
-    start: async () => {
-      const value = await runtime.launch({
-        logger,
-        cancellationToken,
-        stopAfterExecute,
-        ...runtimeParams,
-      })
-      runtimeStartedCallback()
-      return value
-    },
-    stop: async ({ gracefulStop, stop }, reason) => {
-      // external code can cancel using cancellationToken at any time.
-      // it is important to keep the code inside this stop function because once cancelled
-      // all code after the operation won't execute because it will be rejected with
-      // the cancellation error
-
-      let stoppedGracefully
-
-      if (gracefulStop && gracefulStopAllocatedMs) {
-        logger.debug(
-          `${runtimeLabel}: runtime.gracefulStop() because ${reason}`,
-        )
-
-        const gracefulStopPromise = (async () => {
-          await gracefulStop({ reason })
-          return true
-        })()
-
-        const stopPromise = (async () => {
-          stoppedGracefully = await new Promise(async (resolve) => {
-            const timeoutId = setTimeout(() => {
-              resolve(false)
-            }, gracefulStopAllocatedMs)
-            try {
-              await gracefulStopPromise
-              resolve(true)
-            } finally {
-              clearTimeout(timeoutId)
-            }
-          })
-          if (stoppedGracefully) {
-            return stoppedGracefully
+  const winnerPromise = new Promise((resolve, reject) => {
+    raceCallbacks(
+      {
+        aborted: (cb) => {
+          launchAndExecuteOperation.signal.addEventListener("abort", cb)
+          return () => {
+            launchAndExecuteOperation.signal.removeEventListener("abort", cb)
           }
-
-          logger.debug(
-            `${runtimeLabel}: runtime.stop() because gracefulStop still pending after ${gracefulStopAllocatedMs}ms`,
-          )
-          await stop({ reason, gracefulFailed: true })
-          return false
-        })()
-
-        stoppedGracefully = await Promise.race([
-          gracefulStopPromise,
-          stopPromise,
-        ])
-      } else {
-        await stop({ reason, gracefulFailed: false })
-        stoppedGracefully = false
-      }
-
-      logger.debug(
-        `${runtimeLabel}: runtime stopped${
-          stoppedGracefully ? " gracefully" : ""
-        }`,
-      )
-      runtimeStoppedCallback({ stoppedGracefully })
-    },
+        },
+        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,
+    )
   })
 
-  const launchReturnValue = await launchOperation
-  validateLaunchReturnValue(launchReturnValue)
-  const {
-    execute,
-    disconnected,
-    registerErrorCallback = () => {},
-    registerConsoleCallback = () => {},
-    finalizeExecutionResult = (executionResult) => executionResult,
-  } = launchReturnValue
-
-  logger.debug(createDetailedMessage(`${runtimeLabel}: runtime launched.`))
-
-  logger.debug(`${runtimeLabel}: start execution.`)
-  registerConsoleCallback(runtimeConsoleCallback)
-
-  const executeOperation = createOperation({
-    cancellationToken,
-    start: async () => {
-      let timing = TIMING_BEFORE_EXECUTION
-
-      disconnected.then(() => {
-        logger.debug(`${runtimeLabel}: runtime disconnected ${timing}.`)
-        runtimeDisconnectCallback({ timing })
-      })
-
-      const executed = execute(executeParams)
-
-      timing = TIMING_DURING_EXECUTION
-
-      const raceResult = await promiseTrackRace([disconnected, executed])
-      timing = TIMING_AFTER_EXECUTION
+  launchAndExecuteOperation.throwIfAborted()
+  const winner = await winnerPromise
 
-      if (raceResult.winner === disconnected) {
-        return createDisconnectedExecutionResult()
-      }
-
-      if (stopAfterExecute) {
-        // if there is an error while stopping the runtine
-        // the execution is considered as failed
-        try {
-          await launchOperation.stop(stopAfterExecuteReason)
-        } catch (e) {
-          return finalizeExecutionResult(
-            createErroredExecutionResult({
-              error: e,
-            }),
-          )
-        }
-      } else {
-        // when the process is still alive
-        // we want to catch error to notify runtimeErrorAfterExecutionCallback
-        // and throw that error by default
-        registerErrorCallback((error) => {
-          runtimeErrorAfterExecutionCallback(error)
-        })
-      }
+  if (winner.name === "aborted") {
+    launchAndExecuteOperation.throwIfAborted()
+  }
 
-      const executionResult = raceResult.value
-      const { status } = executionResult
-
-      if (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"]: executionResult.error.stack,
-            ["execute params"]: JSON.stringify(executeParams, null, "  "),
-            ["runtime"]: runtime,
-          }),
-        )
-        return finalizeExecutionResult(
-          createErroredExecutionResult(executionResult),
-        )
-      }
+  if (winner.name === "error") {
+    return createErroredExecutionResult({
+      error: winner.data,
+    })
+  }
 
-      logger.debug(`${runtimeLabel}: execution completed.`)
-      return finalizeExecutionResult(
-        createCompletedExecutionResult(executionResult),
-      )
-    },
-  })
+  if (winner.name === "stopped") {
+    return createErroredExecutionResult({
+      error: new Error(`runtime stopped during execution`),
+    })
+  }
 
-  const executionResult = await executeOperation
+  const executeResult = winner.data
+  const { status } = executeResult
 
-  return executionResult
+  if (status === "errored") {
+    return createErroredExecutionResult(executeResult)
+  }
+  return createCompletedExecutionResult(executeResult)
 }
 
-const createTimedoutExecutionResult = () => {
+const createAbortedExecutionResult = () => {
   return {
-    status: "timedout",
+    status: "aborted",
   }
 }
 
-const createDisconnectedExecutionResult = () => {
+const createTimedoutExecutionResult = () => {
   return {
-    status: "disconnected",
+    status: "timedout",
   }
 }
 
@@ -488,22 +404,42 @@ const normalizeNamespace = (namespace) => {
   return normalized
 }
 
+const composeCallback = (previousCallback, callback) => {
+  return (...args) => {
+    previousCallback(...args)
+    return callback(...args)
+  }
+}
+
+const composeTransformer = (previousTransformer, transformer) => {
+  return async (value) => {
+    const transformedValue = await previousTransformer(value)
+    return transformer(transformedValue)
+  }
+}
+
 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 { disconnected } = launchReturnValue
-  if (!disconnected || typeof disconnected.then !== "function") {
-    throw new Error(`launch must return a disconnected promise, got ${execute}`)
+  const { stoppedCallbackList } = launchReturnValue
+  if (!stoppedCallbackList) {
+    throw new Error(
+      `runtime.launch must return a stoppedCallbackList object, got ${stoppedCallbackList}`,
+    )
   }
 }

package/src/internal/exploring/fetchExploringJson.js

@@ -1,16 +1,15 @@
 import { createDetailedMessage } from "@jsenv/logger"
-import { isCancelError } from "@jsenv/cancellation/main.browser.js"
 
 import { fetchJson } from "../browser-utils/fetchJson.js"
 
-export const fetchExploringJson = async ({ cancellationToken } = {}) => {
+export const fetchExploringJson = async ({ signal } = {}) => {
   try {
     const exploringInfo = await fetchJson("/.jsenv/exploring.json", {
-      cancellationToken,
+      signal,
     })
     return exploringInfo
   } catch (e) {
-    if (isCancelError(e)) {
+    if (signal && signal.aborted && e.name === "AbortError") {
       throw e
     }
     throw new Error(

package/src/internal/fetchUrl.js

@@ -1,5 +1,6 @@
 import { globalAgent } from "node:https"
-import { fetchUrl as serverFetchUrl, headersToObject } from "@jsenv/server"
+import { fetchUrl as serverFetchUrl } from "@jsenv/server"
+import { headersToObject } from "@jsenv/server/src/internal/headersToObject.js"
 
 // ideally we should only pass this to the fetch below
 globalAgent.options.rejectUnauthorized = false
@@ -8,7 +9,10 @@ export const fetchUrl = async (
   url,
   { ignoreHttpsError = true, ...rest } = {},
 ) => {
-  const response = await serverFetchUrl(url, { ignoreHttpsError, ...rest })
+  const response = await serverFetchUrl(url, {
+    ignoreHttpsError,
+    ...rest,
+  })
 
   return {
     url: response.url,

package/src/internal/logs/msAsDuration.js

@@ -5,7 +5,7 @@ const humanizeDuration = require("humanize-duration")
 export const msAsDuration = (metricValue) => {
   return humanizeDuration(metricValue, {
     largest: 2,
-    maxDecimalPoints: metricValue < 1 ? 4 : metricValue < 1000 ? 3 : 2,
+    maxDecimalPoints: metricValue < 0.1 ? 3 : metricValue < 1000 ? 2 : 1,
     // units: ["s"]
   })
 }

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) {