@jsenv/core 23.1.3 → 23.2.2

package/src/internal/executing/createSummaryLog.js

@@ -1,11 +1,6 @@
-import {
-  setANSIColor,
-  ANSI_MAGENTA,
-  ANSI_YELLOW,
-  ANSI_RED,
-  ANSI_GREEN,
-} from "../logs/log_style.js"
+import { setANSIColor } from "../logs/log_style.js"
 import { msAsDuration } from "../logs/msAsDuration.js"
+import { EXECUTION_COLORS } from "./execution_colors.js"
 
 export const createSummaryLog = (summary) => `
 -------------- summary -----------------
@@ -15,88 +10,106 @@ ${createSummaryMessage(summary)}${createTotalDurationMessage(summary)}
 
 const createSummaryMessage = ({
   executionCount,
-  disconnectedCount,
+  abortedCount,
   timedoutCount,
   erroredCount,
   completedCount,
+  cancelledCount,
 }) => {
   if (executionCount === 0) {
-    return `0 execution`
+    return `no execution`
   }
 
   return `${executionCount} execution: ${createSummaryDetails({
     executionCount,
-    disconnectedCount,
+    abortedCount,
     timedoutCount,
     erroredCount,
     completedCount,
+    cancelledCount,
   })}`
 }
 
 export const createSummaryDetails = ({
   executionCount,
-  disconnectedCount,
+  abortedCount,
   timedoutCount,
   erroredCount,
   completedCount,
+  cancelledCount,
 }) => {
-  if (disconnectedCount === executionCount) {
-    return createAllDisconnectedDetails()
+  if (abortedCount === executionCount) {
+    return `all ${setANSIColor(`aborted`, EXECUTION_COLORS.aborted)}`
   }
   if (timedoutCount === executionCount) {
-    return createAllTimedoutDetails()
+    return `all ${setANSIColor(`timed out`, EXECUTION_COLORS.timedout)}`
   }
   if (erroredCount === executionCount) {
-    return createAllErroredDetails()
+    return `all ${setANSIColor(`errored`, EXECUTION_COLORS.errored)}`
   }
   if (completedCount === executionCount) {
-    return createAllCompletedDetails()
+    return `all ${setANSIColor(`completed`, EXECUTION_COLORS.completed)}`
+  }
+  if (cancelledCount === executionCount) {
+    return `all ${setANSIColor(`cancelled`, EXECUTION_COLORS.cancelled)}`
   }
 
   return createMixedDetails({
     executionCount,
-    disconnectedCount,
+    abortedCount,
     timedoutCount,
     erroredCount,
     completedCount,
+    cancelledCount,
   })
 }
 
-const createAllDisconnectedDetails = () =>
-  `all ${setANSIColor(`disconnected`, ANSI_MAGENTA)}`
-
-const createAllTimedoutDetails = () =>
-  `all ${setANSIColor(`timed out`, ANSI_YELLOW)}`
-
-const createAllErroredDetails = () => `all ${setANSIColor(`errored`, ANSI_RED)}`
-
-const createAllCompletedDetails = () =>
-  `all ${setANSIColor(`completed`, ANSI_GREEN)}`
-
 const createMixedDetails = ({
-  disconnectedCount,
+  abortedCount,
   timedoutCount,
   erroredCount,
   completedCount,
+  cancelledCount,
 }) => {
   const parts = []
 
-  if (disconnectedCount) {
+  if (timedoutCount) {
     parts.push(
-      `${disconnectedCount} ${setANSIColor(`disconnected`, ANSI_MAGENTA)}`,
+      `${timedoutCount} ${setANSIColor(
+        `timed out`,
+        EXECUTION_COLORS.timedout,
+      )}`,
     )
   }
 
-  if (timedoutCount) {
-    parts.push(`${timedoutCount} ${setANSIColor(`timed out`, ANSI_YELLOW)}`)
-  }
-
   if (erroredCount) {
-    parts.push(`${erroredCount} ${setANSIColor(`errored`, ANSI_RED)}`)
+    parts.push(
+      `${erroredCount} ${setANSIColor(`errored`, EXECUTION_COLORS.errored)}`,
+    )
   }
 
   if (completedCount) {
-    parts.push(`${completedCount} ${setANSIColor(`completed`, ANSI_GREEN)}`)
+    parts.push(
+      `${completedCount} ${setANSIColor(
+        `completed`,
+        EXECUTION_COLORS.completed,
+      )}`,
+    )
+  }
+
+  if (abortedCount) {
+    parts.push(
+      `${abortedCount} ${setANSIColor(`aborted`, EXECUTION_COLORS.aborted)}`,
+    )
+  }
+
+  if (cancelledCount) {
+    parts.push(
+      `${cancelledCount} ${setANSIColor(
+        `cancelled`,
+        EXECUTION_COLORS.cancelled,
+      )}`,
+    )
   }
 
   return `${parts.join(", ")}`

package/src/internal/executing/executeConcurrently.js

@@ -1,13 +1,5 @@
-/* eslint-disable import/max-dependencies */
-import { cpus } from "os"
-import { stat } from "fs"
-
+import { stat } from "node:fs"
 import wrapAnsi from "wrap-ansi"
-import {
-  createConcurrentOperations,
-  createCancellationSource,
-  composeCancellationToken,
-} from "@jsenv/cancellation"
 import { loggerToLevels, createDetailedMessage } from "@jsenv/logger"
 import { urlToFileSystemPath } from "@jsenv/filesystem"
 
@@ -20,9 +12,10 @@ import { createSummaryLog } from "./createSummaryLog.js"
 export const executeConcurrently = async (
   executionSteps,
   {
+    multipleExecutionsOperation,
+
     logger,
     launchAndExecuteLogLevel,
-    cancellationToken,
 
     projectDirectoryUrl,
     compileServerOrigin,
@@ -31,7 +24,7 @@ export const executeConcurrently = async (
     babelPluginMap,
 
     defaultMsAllocatedPerExecution = 30000,
-    concurrencyLimit = Math.max(cpus.length - 1, 1),
+    maxExecutionsInParallel = 1,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     measureGlobalDuration = true,
@@ -59,25 +52,19 @@ export const executeConcurrently = async (
 ) => {
   const startMs = Date.now()
 
-  const allStepDoneCancellationSource = createCancellationSource()
-  const executionCancellationToken = composeCancellationToken(
-    cancellationToken,
-    allStepDoneCancellationSource.token,
-  )
-
   const report = {}
   const executionCount = executionSteps.length
 
   let previousExecutionResult
   let previousExecutionLog
-  let disconnectedCount = 0
+  let abortedCount = 0
   let timedoutCount = 0
   let erroredCount = 0
   let completedCount = 0
-  await createConcurrentOperations({
-    cancellationToken,
-    concurrencyLimit,
-    array: executionSteps,
+  const executionsDone = await executeInParallel({
+    multipleExecutionsOperation,
+    maxExecutionsInParallel,
+    executionSteps,
     start: async (paramsFromStep) => {
       const executionIndex = executionSteps.indexOf(paramsFromStep)
       const { executionName, fileRelativeUrl } = paramsFromStep
@@ -120,9 +107,12 @@ export const executeConcurrently = async (
 
       beforeExecutionCallback(beforeExecutionInfo)
 
+      // launchAndExecute peut retourner un aborted
+      // et c'est bien, on veut le gérer, si tous les suivants sont aborted
+      // on le gere en dehors de cette boucle
       const executionResult = await launchAndExecute({
+        signal: multipleExecutionsOperation.signal,
         launchAndExecuteLogLevel,
-        cancellationToken: executionCancellationToken,
 
         ...executionParams,
         collectCoverage: coverage,
@@ -139,7 +129,6 @@ export const executeConcurrently = async (
           fileRelativeUrl,
           ...executionParams.executeParams,
         },
-
         coverageV8MergeConflictIsExpected,
       })
       const afterExecutionInfo = {
@@ -148,10 +137,10 @@ export const executeConcurrently = async (
       }
       afterExecutionCallback(afterExecutionInfo)
 
-      if (executionResult.status === "timedout") {
+      if (executionResult.status === "aborted") {
+        abortedCount++
+      } else if (executionResult.status === "timedout") {
         timedoutCount++
-      } else if (executionResult.status === "disconnected") {
-        disconnectedCount++
       } else if (executionResult.status === "errored") {
         erroredCount++
       } else if (executionResult.status === "completed") {
@@ -162,7 +151,7 @@ export const executeConcurrently = async (
         let log = createExecutionResultLog(afterExecutionInfo, {
           completedExecutionLogAbbreviation,
           executionCount,
-          disconnectedCount,
+          abortedCount,
           timedoutCount,
           erroredCount,
           completedCount,
@@ -200,28 +189,39 @@ export const executeConcurrently = async (
     },
   })
 
-  // tell everyone we are done
-  // (used to stop potential chrome browser still opened to be reused)
-  allStepDoneCancellationSource.cancel("all execution done")
+  const summaryCounts = reportToSummary(report)
 
-  const summary = reportToSummary(report)
-  if (measureGlobalDuration) {
-    summary.startMs = startMs
-    summary.endMs = Date.now()
+  const summary = {
+    executionCount,
+    ...summaryCounts,
+    // when execution is aborted, the remaining executions are "cancelled"
+    cancelledCount:
+      executionCount -
+      executionsDone.length -
+      // we substract abortedCount because they are not pushed into executionsDone
+      summaryCounts.abortedCount,
+    ...(measureGlobalDuration ? { startMs, endMs: Date.now() } : {}),
   }
-
   if (logSummary) {
     logger.info(createSummaryLog(summary))
   }
 
+  if (multipleExecutionsOperation.signal.aborted) {
+    // don't try to do the coverage stuff
+    return {
+      summary,
+      report,
+    }
+  }
+
   return {
     summary,
     report,
     ...(coverage
       ? {
           coverage: await reportToCoverage(report, {
+            multipleExecutionsOperation,
             logger,
-            cancellationToken,
             projectDirectoryUrl,
             babelPluginMap,
             coverageConfig,
@@ -233,8 +233,55 @@ export const executeConcurrently = async (
   }
 }
 
-const pathLeadsToFile = (path) =>
-  new Promise((resolve, reject) => {
+const executeInParallel = async ({
+  multipleExecutionsOperation,
+  executionSteps,
+  start,
+  maxExecutionsInParallel = 1,
+}) => {
+  const executionResults = []
+  let progressionIndex = 0
+  let remainingExecutionCount = executionSteps.length
+
+  const nextChunk = async () => {
+    if (multipleExecutionsOperation.signal.aborted) {
+      return
+    }
+
+    const outputPromiseArray = []
+    while (
+      remainingExecutionCount > 0 &&
+      outputPromiseArray.length < maxExecutionsInParallel
+    ) {
+      remainingExecutionCount--
+      const outputPromise = executeOne(progressionIndex)
+      progressionIndex++
+      outputPromiseArray.push(outputPromise)
+    }
+
+    if (outputPromiseArray.length) {
+      await Promise.all(outputPromiseArray)
+      if (remainingExecutionCount > 0) {
+        await nextChunk()
+      }
+    }
+  }
+
+  const executeOne = async (index) => {
+    const input = executionSteps[index]
+    const output = await start(input)
+    if (!multipleExecutionsOperation.signal.aborted) {
+      executionResults[index] = output
+    }
+  }
+
+  await nextChunk()
+
+  return executionResults
+}
+
+const pathLeadsToFile = (path) => {
+  return new Promise((resolve, reject) => {
     stat(path, (error, stats) => {
       if (error) {
         if (error.code === "ENOENT") {
@@ -247,12 +294,10 @@ const pathLeadsToFile = (path) =>
       }
     })
   })
+}
 
 const reportToSummary = (report) => {
   const fileNames = Object.keys(report)
-  const executionCount = fileNames.reduce((previous, fileName) => {
-    return previous + Object.keys(report[fileName]).length
-  }, 0)
 
   const countResultMatching = (predicate) => {
     return fileNames.reduce((previous, fileName) => {
@@ -269,9 +314,7 @@ const reportToSummary = (report) => {
     }, 0)
   }
 
-  const disconnectedCount = countResultMatching(
-    ({ status }) => status === "disconnected",
-  )
+  const abortedCount = countResultMatching(({ status }) => status === "aborted")
   const timedoutCount = countResultMatching(
     ({ status }) => status === "timedout",
   )
@@ -281,8 +324,7 @@ const reportToSummary = (report) => {
   )
 
   return {
-    executionCount,
-    disconnectedCount,
+    abortedCount,
     timedoutCount,
     erroredCount,
     completedCount,

package/src/internal/executing/executePlan.js

@@ -1,3 +1,7 @@
+import {
+  Abortable,
+  raceProcessTeardownEvents,
+} from "@jsenv/core/src/abort/main.js"
 import { mergeRuntimeSupport } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
 import { startCompileServer } from "../compiling/startCompileServer.js"
 import { babelPluginInstrument } from "./coverage/babel_plugin_instrument.js"
@@ -7,10 +11,12 @@ import { executeConcurrently } from "./executeConcurrently.js"
 export const executePlan = async (
   plan,
   {
+    signal,
+    handleSIGINT,
+
     logger,
     compileServerLogLevel,
     launchAndExecuteLogLevel,
-    cancellationToken,
 
     projectDirectoryUrl,
     jsenvDirectoryRelativeUrl,
@@ -20,7 +26,7 @@ export const executePlan = async (
     importDefaultExtension,
 
     defaultMsAllocatedPerExecution,
-    concurrencyLimit,
+    maxExecutionsInParallel,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     logSummary,
@@ -68,8 +74,23 @@ export const executePlan = async (
     })
   })
 
+  const multipleExecutionsOperation = Abortable.fromSignal(signal)
+  if (handleSIGINT) {
+    Abortable.effect(multipleExecutionsOperation, (cb) =>
+      raceProcessTeardownEvents(
+        {
+          SIGINT: true,
+        },
+        () => {
+          logger.info("Aborting execution (SIGINT)")
+          cb()
+        },
+      ),
+    )
+  }
+
   const compileServer = await startCompileServer({
-    cancellationToken,
+    signal: multipleExecutionsOperation.signal,
     compileServerLogLevel,
 
     projectDirectoryUrl,
@@ -94,21 +115,25 @@ export const executePlan = async (
     runtimeSupport,
   })
 
+  multipleExecutionsOperation.cleaner.addCallback(async () => {
+    await compileServer.stop()
+  })
+
   const executionSteps = await generateExecutionSteps(
     {
       ...plan,
       [compileServer.outDirectoryRelativeUrl]: null,
     },
     {
-      cancellationToken,
+      signal: multipleExecutionsOperation.signal,
       projectDirectoryUrl,
     },
   )
 
   const result = await executeConcurrently(executionSteps, {
+    multipleExecutionsOperation,
     logger,
     launchAndExecuteLogLevel,
-    cancellationToken,
 
     projectDirectoryUrl,
     compileServerOrigin: compileServer.origin,
@@ -121,7 +146,7 @@ export const executePlan = async (
     babelPluginMap: compileServer.babelPluginMap,
 
     defaultMsAllocatedPerExecution,
-    concurrencyLimit,
+    maxExecutionsInParallel,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     logSummary,
@@ -134,7 +159,8 @@ export const executePlan = async (
     coverageV8MergeConflictIsExpected,
   })
 
-  compileServer.stop("all execution done")
+  // (used to stop potential chrome browser still opened to be reused)
+  multipleExecutionsOperation.cleaner.clean("all execution done")
 
   return {
     planSummary: result.summary,

package/src/internal/executing/executionLogs.js

@@ -1,14 +1,11 @@
 import {
-  failureSignDefault,
-  okSignDefault,
+  failureSignColorLess,
+  okSignColorLess,
   setANSIColor,
-  ANSI_MAGENTA,
-  ANSI_YELLOW,
-  ANSI_RED,
   ANSI_GREY,
-  ANSI_GREEN,
 } from "../logs/log_style.js"
 import { msAsDuration } from "../logs/msAsDuration.js"
+import { EXECUTION_COLORS } from "./execution_colors.js"
 import { createSummaryDetails } from "./createSummaryLog.js"
 
 export const createExecutionResultLog = (
@@ -16,7 +13,7 @@ export const createExecutionResultLog = (
   {
     completedExecutionLogAbbreviation,
     executionCount,
-    disconnectedCount,
+    abortedCount,
     timedoutCount,
     erroredCount,
     completedCount,
@@ -33,7 +30,7 @@ export const createExecutionResultLog = (
   })
   const summary = `(${createSummaryDetails({
     executionCount: executionNumber,
-    disconnectedCount,
+    abortedCount,
     timedoutCount,
     erroredCount,
     completedCount,
@@ -54,32 +51,38 @@ file: ${fileRelativeUrl}
 runtime: ${runtime}${appendDuration({
     startMs,
     endMs,
-  })}${appendConsole(consoleCalls)}${appendError(error, runtimeName)}`
+  })}${appendConsole(consoleCalls)}${appendError(error)}`
 }
 
 const descriptionFormatters = {
-  disconnected: ({ executionNumber, executionCount }) => {
+  aborted: ({ executionNumber, executionCount }) => {
     return setANSIColor(
-      `${failureSignDefault} execution ${executionNumber} of ${executionCount} disconnected`,
-      ANSI_MAGENTA,
+      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} aborted`,
+      EXECUTION_COLORS.aborted,
     )
   },
   timedout: ({ executionNumber, allocatedMs, executionCount }) => {
     return setANSIColor(
-      `${failureSignDefault} execution ${executionNumber} of ${executionCount} timeout after ${allocatedMs}ms`,
-      ANSI_YELLOW,
+      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} timeout after ${allocatedMs}ms`,
+      EXECUTION_COLORS.timedout,
     )
   },
   errored: ({ executionNumber, executionCount }) => {
     return setANSIColor(
-      `${failureSignDefault} execution ${executionNumber} of ${executionCount} error`,
-      ANSI_RED,
+      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} error`,
+      EXECUTION_COLORS.errored,
     )
   },
   completed: ({ executionNumber, executionCount }) => {
     return setANSIColor(
-      `${okSignDefault} execution ${executionNumber} of ${executionCount} completed`,
-      ANSI_GREEN,
+      `${okSignColorLess} execution ${executionNumber} of ${executionCount} completed`,
+      EXECUTION_COLORS.completed,
+    )
+  },
+  cancelled: ({ executionNumber, executionCount }) => {
+    return setANSIColor(
+      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} cancelled`,
+      EXECUTION_COLORS.cancelled,
     )
   },
 }
@@ -107,21 +110,15 @@ ${consoleOutputTrimmed}
 ${setANSIColor(`-------------------------`, ANSI_GREY)}`
 }
 
-const appendError = (error, runtimeName) => {
+const appendError = (error) => {
   if (!error) {
     return ``
   }
 
-  if (runtimeName === "webkit") {
-    return `
-error: ${error.message}
-  at ${error.stack}`
-  }
-
   return `
 error: ${error.stack}`
 }
 
-export const createShortExecutionResultLog = () => {
-  return `Execution completed (2/9) - (all completed)`
-}
+// export const createShortExecutionResultLog = () => {
+//   return `Execution completed (2/9) - (all completed)`
+// }

package/src/internal/executing/execution_colors.js

@@ -0,0 +1,15 @@
+import {
+  ANSI_GREY,
+  ANSI_YELLOW,
+  ANSI_RED,
+  ANSI_GREEN,
+  ANSI_MAGENTA,
+} from "../logs/log_style.js"
+
+export const EXECUTION_COLORS = {
+  aborted: ANSI_MAGENTA,
+  timedout: ANSI_YELLOW,
+  errored: ANSI_RED,
+  completed: ANSI_GREEN,
+  cancelled: ANSI_GREY,
+}

package/src/internal/executing/generateExecutionSteps.js

@@ -1,16 +1,17 @@
 import { collectFiles } from "@jsenv/filesystem"
+
 import { generateFileExecutionSteps } from "./generateFileExecutionSteps.js"
 
 export const generateExecutionSteps = async (
   plan,
-  { cancellationToken, projectDirectoryUrl },
+  { signal, projectDirectoryUrl },
 ) => {
   const structuredMetaMap = {
     filePlan: plan,
   }
 
   const fileResultArray = await collectFiles({
-    cancellationToken,
+    signal,
     directoryUrl: projectDirectoryUrl,
     structuredMetaMap,
     predicate: ({ filePlan }) => filePlan,