nx 21.0.0-rc.3 → 21.0.0

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.d.ts

@@ -1,8 +1,9 @@
-import { Task } from '../../config/task-graph';
+import { Task, TaskGraph } from '../../config/task-graph';
 import type { LifeCycle } from '../life-cycle';
-export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }: {
+export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }: {
     projectNames: string[];
     tasks: Task[];
+    taskGraph: TaskGraph;
     args: {
         targets?: string[];
         configuration?: string;

package/src/tasks-runner/life-cycles/tui-summary-life-cycle.js

@@ -8,10 +8,11 @@ const pretty_time_1 = require("./pretty-time");
 const view_logs_utils_1 = require("./view-logs-utils");
 const figures = require("figures");
 const task_history_life_cycle_1 = require("./task-history-life-cycle");
+const task_graph_utils_1 = require("../task-graph-utils");
 const LEFT_PAD = `   `;
 const SPACER = `  `;
 const EXTENDED_LEFT_PAD = `      `;
-function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }) {
+function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }) {
     const lifeCycle = {};
     const start = process.hrtime();
     const targets = args.targets;
@@ -74,17 +75,32 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             console.log(`\n${output_1.output.applyNxPrefix('gray', 'No tasks were run')}\n`);
             return;
         }
+        const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
+        const cancelled = 
+        // Some tasks were in progress...
+        inProgressTasks.size > 0 ||
+            // or some tasks had not started yet
+            totalTasks !== tasks.length ||
+            // the run had a continous task as a leaf...
+            // this is needed because continous tasks get marked as stopped when the process is interrupted
+            [...(0, task_graph_utils_1.getLeafTasks)(taskGraph)].filter((t) => taskGraph.tasks[t].continuous)
+                .length > 0;
         if (isRunOne) {
-            printRunOneSummary();
+            printRunOneSummary({
+                failure,
+                cancelled,
+            });
         }
         else {
-            printRunManySummary();
+            printRunManySummary({
+                failure,
+                cancelled,
+            });
         }
         (0, task_history_life_cycle_1.getTasksHistoryLifeCycle)()?.printFlakyTasksMessage();
     };
-    const printRunOneSummary = () => {
+    const printRunOneSummary = ({ failure, cancelled, }) => {
         let lines = [];
-        const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
         // Prints task outputs in the order they were completed
         // above the summary, since run-one should print all task results.
         for (const taskId of taskIdsInOrderOfCompletion) {
@@ -92,7 +108,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             output_1.output.logCommandOutput(taskId, taskStatus, terminalOutput);
         }
         lines.push(...output_1.output.getVerticalSeparatorLines(failure ? 'red' : 'green'));
-        if (!failure) {
+        if (!failure && !cancelled) {
             const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], targets, tasks)}`;
             const taskOverridesLines = [];
             if (Object.keys(overrides).length > 0) {
@@ -108,7 +124,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             }
             lines = [output_1.output.colors.green(lines.join(node_os_1.EOL))];
         }
-        else if (inProgressTasks.size === 0) {
+        else if (!cancelled) {
             let text = `Ran target ${output_1.output.bold(targets[0])} for project ${output_1.output.bold(initiatingProject)}`;
             if (tasks.length > 1) {
                 text += ` and ${output_1.output.bold(tasks.length - 1)} task(s) they depend on`;
@@ -138,10 +154,9 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
         lines.push('');
         console.log(lines.join(node_os_1.EOL));
     };
-    const printRunManySummary = () => {
+    const printRunManySummary = ({ failure, cancelled, }) => {
         console.log('');
         const lines = [''];
-        const failure = totalSuccessfulTasks + stoppedTasks.size !== totalTasks;
         for (const taskId of taskIdsInOrderOfCompletion) {
             const { terminalOutput, taskStatus } = tasksToTerminalOutputs[taskId];
             if (taskStatus === 'failure') {
@@ -175,7 +190,7 @@ function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, args, overrides,
             lines.push(successSummaryRows.join(node_os_1.EOL));
         }
         else {
-            const text = `${inProgressTasks.size ? 'Cancelled while running' : 'Ran'} ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
+            const text = `${cancelled ? 'Cancelled while running' : 'Ran'} ${(0, formatting_utils_1.formatTargetsAndProjects)(projectNames, targets, tasks)}`;
             const taskOverridesRows = [];
             if (Object.keys(overrides).length > 0) {
                 taskOverridesRows.push('');

package/src/tasks-runner/run-command.d.ts

@@ -16,7 +16,10 @@ export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNod
 }, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
     excludeTaskDependencies: boolean;
     loadDotEnvFiles: boolean;
-}): Promise<TaskResults>;
+}): Promise<{
+    taskResults: TaskResults;
+    completed: boolean;
+}>;
 export declare function setEnvVarsBasedOnArgs(nxArgs: NxArgs, loadDotEnvFiles: boolean): void;
 export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, initiatingTasks, }: {
     tasks: Task[];

package/src/tasks-runner/run-command.js

@@ -40,6 +40,7 @@ const tui_summary_life_cycle_1 = require("./life-cycles/tui-summary-life-cycle")
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
+const exit_codes_1 = require("../utils/exit-codes");
 const originalStdoutWrite = process.stdout.write.bind(process.stdout);
 const originalStderrWrite = process.stderr.write.bind(process.stderr);
 const originalConsoleLog = console.log.bind(console);
@@ -107,6 +108,7 @@ async function getTerminalOutputLifeCycle(initiatingProject, initiatingTasks, pr
         const { lifeCycle: tsLifeCycle, printSummary } = (0, tui_summary_life_cycle_1.getTuiTerminalSummaryLifeCycle)({
             projectNames,
             tasks,
+            taskGraph,
             args: nxArgs,
             overrides: overridesWithoutHidden,
             initiatingProject,
@@ -277,21 +279,23 @@ async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs
             workspaceRoot: workspace_root_1.workspaceRoot,
             nxJsonConfiguration: nxJson,
         });
-        const taskResults = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, {
+        const { taskResults, completed } = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, {
             ...nxArgs,
             skipNxCache: nxArgs.skipNxCache ||
                 process.env.NX_SKIP_NX_CACHE === 'true' ||
                 process.env.NX_DISABLE_NX_CACHE === 'true',
         }, overrides, initiatingProject, extraTargetDependencies, extraOptions);
-        const result = Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
-            ? 1
-            : 0;
+        const exitCode = !completed
+            ? (0, exit_codes_1.signalToCode)('SIGINT')
+            : Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+                ? 1
+                : 0;
         await (0, tasks_execution_hooks_1.runPostTasksExecution)({
             taskResults,
             workspaceRoot: workspace_root_1.workspaceRoot,
             nxJsonConfiguration: nxJson,
         });
-        return result;
+        return exitCode;
     });
     return status;
 }
@@ -320,7 +324,10 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
             printSummary();
         }
         await (0, nx_key_1.printNxKey)();
-        return taskResults;
+        return {
+            taskResults,
+            completed: didCommandComplete(tasks, taskGraph, taskResults),
+        };
     }
     catch (e) {
         if (restoreTerminal) {
@@ -329,6 +336,30 @@ async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }
         throw e;
     }
 }
+function didCommandComplete(tasks, taskGraph, taskResults) {
+    // If no tasks, then we can consider it complete
+    if (tasks.length === 0) {
+        return true;
+    }
+    let continousLeafTasks = false;
+    const leafTasks = (0, task_graph_utils_1.getLeafTasks)(taskGraph);
+    for (const task of tasks) {
+        if (!task.continuous) {
+            // If any discrete task does not have a result then it did not run
+            if (!taskResults[task.id]) {
+                return false;
+            }
+        }
+        else {
+            if (leafTasks.has(task.id)) {
+                continousLeafTasks = true;
+            }
+        }
+    }
+    // If a leaf task is continous, we must have cancelled it.
+    // Otherwise, we've looped through all the discrete tasks and they have results
+    return !continousLeafTasks;
+}
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
     let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
     if (nxArgs.skipSync || (0, is_ci_1.isCI)()) {

package/src/tasks-runner/task-graph-utils.d.ts

@@ -22,3 +22,4 @@ export declare function makeAcyclic(graph: {
 }): void;
 export declare function validateNoAtomizedTasks(taskGraph: TaskGraph, projectGraph: ProjectGraph): void;
 export declare function assertTaskGraphDoesNotContainInvalidTargets(taskGraph: TaskGraph): void;
+export declare function getLeafTasks(taskGraph: TaskGraph): Set<string>;

package/src/tasks-runner/task-graph-utils.js

@@ -5,6 +5,7 @@ exports.findCycles = findCycles;
 exports.makeAcyclic = makeAcyclic;
 exports.validateNoAtomizedTasks = validateNoAtomizedTasks;
 exports.assertTaskGraphDoesNotContainInvalidTargets = assertTaskGraphDoesNotContainInvalidTargets;
+exports.getLeafTasks = getLeafTasks;
 const output_1 = require("../utils/output");
 function _findCycle(graph, id, visited, path) {
     if (visited[id])
@@ -138,3 +139,30 @@ class NonParallelTaskDependsOnContinuousTasksError extends Error {
         this.name = 'NonParallelTaskDependsOnContinuousTasksError';
     }
 }
+function getLeafTasks(taskGraph) {
+    const reversed = reverseTaskGraph(taskGraph);
+    const leafTasks = new Set();
+    for (const [taskId, dependencies] of Object.entries(reversed.dependencies)) {
+        if (dependencies.length === 0) {
+            leafTasks.add(taskId);
+        }
+    }
+    return leafTasks;
+}
+function reverseTaskGraph(taskGraph) {
+    const reversed = {
+        tasks: taskGraph.tasks,
+        dependencies: Object.fromEntries(Object.entries(taskGraph.tasks).map(([taskId]) => [taskId, []])),
+    };
+    for (const [taskId, dependencies] of Object.entries(taskGraph.dependencies)) {
+        for (const dependency of dependencies) {
+            reversed.dependencies[dependency].push(taskId);
+        }
+    }
+    for (const [taskId, dependencies] of Object.entries(taskGraph.continuousDependencies)) {
+        for (const dependency of dependencies) {
+            reversed.dependencies[dependency].push(taskId);
+        }
+    }
+    return reversed;
+}

package/src/tasks-runner/task-orchestrator.d.ts

@@ -38,6 +38,7 @@ export declare class TaskOrchestrator {
     private groups;
     private bailed;
     private runningContinuousTasks;
+    private runningRunCommandsTasks;
     constructor(hasher: TaskHasher, initiatingProject: string | undefined, initiatingTasks: Task[], projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string, taskGraphForHashing?: TaskGraph);
     init(): Promise<void>;
     run(): Promise<{

package/src/tasks-runner/task-orchestrator.js

@@ -55,6 +55,7 @@ class TaskOrchestrator {
         this.groups = [];
         this.bailed = false;
         this.runningContinuousTasks = new Map();
+        this.runningRunCommandsTasks = new Map();
     }
     async init() {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
@@ -324,6 +325,10 @@ class TaskOrchestrator {
                 const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
                 });
+                this.runningRunCommandsTasks.set(task.id, runningTask);
+                runningTask.onExit(() => {
+                    this.runningRunCommandsTasks.delete(task.id);
+                });
                 if (this.tuiEnabled) {
                     if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
                         // This is an external of a the pseudo terminal where a task is running and can be passed to the TUI
@@ -640,18 +645,28 @@ class TaskOrchestrator {
     }
     // endregion utils
     async cleanup() {
-        await Promise.all(Array.from(this.runningContinuousTasks).map(async ([taskId, t]) => {
-            try {
-                await t.kill();
-                this.options.lifeCycle.setTaskStatus(taskId, 9 /* NativeTaskStatus.Stopped */);
-            }
-            catch (e) {
-                console.error(`Unable to terminate ${taskId}\nError:`, e);
-            }
-            finally {
-                this.runningTasksService.removeRunningTask(taskId);
-            }
-        }));
+        await Promise.all([
+            ...Array.from(this.runningContinuousTasks).map(async ([taskId, t]) => {
+                try {
+                    await t.kill();
+                    this.options.lifeCycle.setTaskStatus(taskId, 9 /* NativeTaskStatus.Stopped */);
+                }
+                catch (e) {
+                    console.error(`Unable to terminate ${taskId}\nError:`, e);
+                }
+                finally {
+                    this.runningTasksService.removeRunningTask(taskId);
+                }
+            }),
+            ...Array.from(this.runningRunCommandsTasks).map(async ([taskId, t]) => {
+                try {
+                    await t.kill();
+                }
+                catch (e) {
+                    console.error(`Unable to terminate ${taskId}\nError:`, e);
+                }
+            }),
+        ]);
     }
     cleanUpUnneededContinuousTasks() {
         const incompleteTasks = this.tasksSchedule.getIncompleteTasks();