nx 21.0.0-canary.20250422-8619c1d → 21.0.0-canary.20250424-e23b25f

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

@@ -21,11 +21,13 @@ const noop_child_process_1 = require("./running-tasks/noop-child-process");
 const task_env_1 = require("./task-env");
 const tasks_schedule_1 = require("./tasks-schedule");
 const utils_1 = require("./utils");
+const shared_running_task_1 = require("./running-tasks/shared-running-task");
 class TaskOrchestrator {
     // endregion internal state
-    constructor(hasher, initiatingProject, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
+    constructor(hasher, initiatingProject, initiatingTasks, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle, taskGraphForHashing = taskGraph) {
         this.hasher = hasher;
         this.initiatingProject = initiatingProject;
+        this.initiatingTasks = initiatingTasks;
         this.projectGraph = projectGraph;
         this.taskGraph = taskGraph;
         this.nxJson = nxJson;
@@ -43,6 +45,7 @@ class TaskOrchestrator {
         // region internal state
         this.batchEnv = (0, task_env_1.getEnvVariablesForBatchProcess)(this.options.skipNxCache, this.options.captureStderr);
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
+        this.initializingTaskIds = new Set(this.initiatingTasks.map((t) => t.id));
         this.processedTasks = new Map();
         this.processedBatches = new Map();
         this.completedTasks = {};
@@ -50,7 +53,6 @@ class TaskOrchestrator {
         this.groups = [];
         this.bailed = false;
         this.runningContinuousTasks = new Map();
-        this.cleaningUp = false;
     }
     async init() {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
@@ -300,9 +302,17 @@ class TaskOrchestrator {
                 const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
                 });
-                if (this.tuiEnabled && 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
-                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                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
+                        this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                    }
+                    else {
+                        this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
+                        runningTask.onOutput((output) => {
+                            this.options.lifeCycle.appendTaskOutput(task.id, output);
+                        });
+                    }
                 }
                 if (!streamOutput) {
                     if (runningTask instanceof pseudo_terminal_1.PseudoTtyProcess) {
@@ -350,9 +360,17 @@ class TaskOrchestrator {
         else {
             // cache prep
             const runningTask = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-            if (this.tuiEnabled && 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
-                this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+            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
+                    this.options.lifeCycle.registerRunningTask(task.id, runningTask.getParserAndWriter());
+                }
+                else if ('onOutput' in runningTask) {
+                    this.options.lifeCycle.registerRunningTaskWithEmptyParser(task.id);
+                    runningTask.onOutput((output) => {
+                        this.options.lifeCycle.appendTaskOutput(task.id, output);
+                    });
+                }
             }
             return runningTask;
         }
@@ -397,15 +415,27 @@ class TaskOrchestrator {
             if (this.tuiEnabled) {
                 this.options.lifeCycle.setTaskStatus(task.id, 8 /* NativeTaskStatus.Shared */);
             }
+            const runningTask = new shared_running_task_1.SharedRunningTask(this.runningTasksService, task.id);
+            this.runningContinuousTasks.set(task.id, runningTask);
+            runningTask.onExit(() => {
+                this.runningContinuousTasks.delete(task.id);
+            });
             // task is already running by another process, we schedule the next tasks
             // and release the threads
             await this.scheduleNextTasksAndReleaseThreads();
-            // wait for the running task to finish
-            do {
-                console.log(`Waiting for ${task.id} in another nx process`);
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            } while (this.runningTasksService.getRunningTasks([task.id]).length);
-            return;
+            if (this.initializingTaskIds.has(task.id)) {
+                await new Promise((res) => {
+                    runningTask.onExit((code) => {
+                        if (!this.tuiEnabled) {
+                            if (code > 128) {
+                                process.exit(code);
+                            }
+                        }
+                        res();
+                    });
+                });
+            }
+            return runningTask;
         }
         const taskSpecificEnv = await this.processedTasks.get(task.id);
         await this.preRunSteps([task], { groupId });
@@ -425,14 +455,20 @@ class TaskOrchestrator {
         this.runningContinuousTasks.set(task.id, childProcess);
         childProcess.onExit(() => {
             this.runningTasksService.removeRunningTask(task.id);
+            this.runningContinuousTasks.delete(task.id);
         });
-        if (this.initiatingProject === task.target.project &&
-            this.options.targets.length === 1 &&
-            this.options.targets[0] === task.target.target) {
-            await childProcess.getResults();
-        }
-        else {
-            await this.scheduleNextTasksAndReleaseThreads();
+        await this.scheduleNextTasksAndReleaseThreads();
+        if (this.initializingTaskIds.has(task.id)) {
+            await new Promise((res) => {
+                childProcess.onExit((code) => {
+                    if (!this.tuiEnabled) {
+                        if (code > 128) {
+                            process.exit(code);
+                        }
+                    }
+                    res();
+                });
+            });
         }
         return childProcess;
     }
@@ -505,6 +541,7 @@ class TaskOrchestrator {
     }
     complete(taskResults) {
         this.tasksSchedule.complete(taskResults.map(({ taskId }) => taskId));
+        this.cleanUpUnneededContinuousTasks();
         for (const { taskId, status } of taskResults) {
             if (this.completedTasks[taskId] === undefined) {
                 this.completedTasks[taskId] = status;
@@ -571,10 +608,10 @@ class TaskOrchestrator {
     }
     // endregion utils
     async cleanup() {
-        this.cleaningUp = true;
         await Promise.all(Array.from(this.runningContinuousTasks).map(async ([taskId, t]) => {
             try {
-                return t.kill();
+                await t.kill();
+                this.options.lifeCycle.setTaskStatus(taskId, 9 /* NativeTaskStatus.Stopped */);
             }
             catch (e) {
                 console.error(`Unable to terminate ${taskId}\nError:`, e);
@@ -584,6 +621,25 @@ class TaskOrchestrator {
             }
         }));
     }
+    cleanUpUnneededContinuousTasks() {
+        const incompleteTasks = this.tasksSchedule.getIncompleteTasks();
+        const neededContinuousTasks = new Set(this.initializingTaskIds);
+        for (const task of incompleteTasks) {
+            const continuousDependencies = this.taskGraph.continuousDependencies[task.id];
+            for (const continuousDependency of continuousDependencies) {
+                neededContinuousTasks.add(continuousDependency);
+            }
+        }
+        for (const taskId of this.runningContinuousTasks.keys()) {
+            if (!neededContinuousTasks.has(taskId)) {
+                const runningTask = this.runningContinuousTasks.get(taskId);
+                if (runningTask) {
+                    runningTask.kill();
+                    this.options.lifeCycle.setTaskStatus(taskId, 9 /* NativeTaskStatus.Stopped */);
+                }
+            }
+        }
+    }
 }
 exports.TaskOrchestrator = TaskOrchestrator;
 function getThreadCount(options, taskGraph) {

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

@@ -12,6 +12,7 @@ export type TaskStatus = 'success' | 'failure' | 'skipped' | 'local-cache-kept-e
 export type TasksRunner<T = unknown> = (tasks: Task[], options: T, context?: {
     target?: string;
     initiatingProject?: string | null;
+    initiatingTasks: Task[];
     projectGraph: ProjectGraph;
     nxJson: NxJsonConfiguration;
     nxArgs: NxArgs;

package/src/tasks-runner/tasks-schedule.d.ts

@@ -31,6 +31,7 @@ export declare class TasksSchedule {
     };
     nextTask(): Task;
     nextBatch(): Batch;
+    getIncompleteTasks(): Task[];
     private scheduleTasks;
     private scheduleTask;
     private scheduleBatches;

package/src/tasks-runner/tasks-schedule.js

@@ -68,6 +68,15 @@ class TasksSchedule {
             ? this.scheduledBatches.shift()
             : null;
     }
+    getIncompleteTasks() {
+        const incompleteTasks = [];
+        for (const taskId in this.taskGraph.tasks) {
+            if (!this.completedTasks.has(taskId)) {
+                incompleteTasks.push(this.taskGraph.tasks[taskId]);
+            }
+        }
+        return incompleteTasks;
+    }
     async scheduleTasks() {
         if (this.options.batch || process.env.NX_BATCH_MODE === 'true') {
             await this.scheduleBatches();

package/src/tasks-runner/utils.js

@@ -374,6 +374,8 @@ function shouldStreamOutput(task, initiatingProject) {
         return false;
     if (process.env.NX_STREAM_OUTPUT === 'true')
         return true;
+    if (process.env.NX_STREAM_OUTPUT === 'false')
+        return false;
     if (longRunningTask(task))
         return true;
     if (task.target.project === initiatingProject)