nx 21.0.0-beta.0 → 21.0.0-beta.10

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

@@ -1,14 +1,17 @@
-import { TaskHasher } from '../hasher/task-hasher';
-import { DefaultTasksRunnerOptions } from './default-tasks-runner';
-import { TaskStatus } from './tasks-runner';
+import { NxJsonConfiguration } from '../config/nx-json';
 import { ProjectGraph } from '../config/project-graph';
-import { TaskGraph } from '../config/task-graph';
+import { Task, TaskGraph } from '../config/task-graph';
 import { DaemonClient } from '../daemon/client/client';
-import { NxJsonConfiguration } from '../config/nx-json';
+import { TaskHasher } from '../hasher/task-hasher';
 import { NxArgs } from '../utils/command-line-utils';
+import { DefaultTasksRunnerOptions } from './default-tasks-runner';
+import { RunningTask } from './running-tasks/running-task';
+import { TaskStatus } from './tasks-runner';
+import { SharedRunningTask } from './running-tasks/shared-running-task';
 export declare class TaskOrchestrator {
     private readonly hasher;
     private readonly initiatingProject;
+    private readonly initiatingTasks;
     private readonly projectGraph;
     private readonly taskGraph;
     private readonly nxJson;
@@ -16,12 +19,16 @@ export declare class TaskOrchestrator {
     private readonly bail;
     private readonly daemon;
     private readonly outputStyle;
+    private readonly taskGraphForHashing;
     private taskDetails;
     private cache;
+    private readonly tuiEnabled;
     private forkedProcessTaskRunner;
+    private runningTasksService;
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
+    private initializingTaskIds;
     private processedTasks;
     private processedBatches;
     private completedTasks;
@@ -29,25 +36,32 @@ export declare class TaskOrchestrator {
     private groups;
     private bailed;
     private runningContinuousTasks;
-    private cleaningUp;
-    constructor(hasher: TaskHasher, initiatingProject: string | undefined, projectGraph: ProjectGraph, taskGraph: TaskGraph, nxJson: NxJsonConfiguration, options: NxArgs & DefaultTasksRunnerOptions, bail: boolean, daemon: DaemonClient, outputStyle: string);
+    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<{
         [id: string]: TaskStatus;
     }>;
     private executeNextBatchOfTasksUsingTaskSchedule;
-    private processScheduledTask;
+    processTasks(taskIds: string[]): void;
+    private processTask;
     private processScheduledBatch;
     private processAllScheduledTasks;
     private applyCachedResults;
     private applyCachedResult;
     private applyFromCacheOrRunBatch;
     private runBatch;
-    private applyFromCacheOrRunTask;
+    applyFromCacheOrRunTask(doNotSkipCache: boolean, task: Task, groupId: number): Promise<{
+        task: Task;
+        code: number;
+        status: TaskStatus;
+        terminalOutput?: string;
+    }>;
     private runTask;
     private runTaskInForkedProcess;
-    private startContinuousTask;
+    startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
     private preRunSteps;
     private postRunSteps;
+    private scheduleNextTasksAndReleaseThreads;
     private complete;
     private pipeOutputCapture;
     private shouldCacheTaskResult;
@@ -56,4 +70,6 @@ export declare class TaskOrchestrator {
     private shouldCopyOutputsFromCache;
     private recordOutputsHash;
     private cleanup;
+    private cleanUpUnneededContinuousTasks;
 }
+export declare function getThreadCount(options: NxArgs & DefaultTasksRunnerOptions, taskGraph: TaskGraph): number;

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

@@ -1,26 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskOrchestrator = void 0;
+exports.getThreadCount = getThreadCount;
 const events_1 = require("events");
-const perf_hooks_1 = require("perf_hooks");
-const path_1 = require("path");
 const fs_1 = require("fs");
+const path_1 = require("path");
+const perf_hooks_1 = require("perf_hooks");
 const run_commands_impl_1 = require("../executors/run-commands/run-commands.impl");
-const forked_process_task_runner_1 = require("./forked-process-task-runner");
-const cache_1 = require("./cache");
-const utils_1 = require("./utils");
-const tasks_schedule_1 = require("./tasks-schedule");
 const hash_task_1 = require("../hasher/hash-task");
-const task_env_1 = require("./task-env");
-const workspace_root_1 = require("../utils/workspace-root");
+const native_1 = require("../native");
+const db_connection_1 = require("../utils/db-connection");
 const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
+const workspace_root_1 = require("../utils/workspace-root");
+const cache_1 = require("./cache");
+const forked_process_task_runner_1 = require("./forked-process-task-runner");
+const is_tui_enabled_1 = require("./is-tui-enabled");
+const pseudo_terminal_1 = require("./pseudo-terminal");
 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) {
+    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;
@@ -28,13 +35,17 @@ class TaskOrchestrator {
         this.bail = bail;
         this.daemon = daemon;
         this.outputStyle = outputStyle;
+        this.taskGraphForHashing = taskGraphForHashing;
         this.taskDetails = (0, hash_task_1.getTaskDetails)();
         this.cache = (0, cache_1.getCache)(this.options);
-        this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options);
+        this.tuiEnabled = (0, is_tui_enabled_1.isTuiEnabled)(this.nxJson);
+        this.forkedProcessTaskRunner = new forked_process_task_runner_1.ForkedProcessTaskRunner(this.options, this.tuiEnabled);
+        this.runningTasksService = new native_1.RunningTasksService((0, db_connection_1.getDbConnection)());
         this.tasksSchedule = new tasks_schedule_1.TasksSchedule(this.projectGraph, this.taskGraph, this.options);
         // 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 = {};
@@ -42,20 +53,21 @@ class TaskOrchestrator {
         this.groups = [];
         this.bailed = false;
         this.runningContinuousTasks = new Map();
-        this.cleaningUp = false;
     }
-    async run() {
+    async init() {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
         await Promise.all([
             this.forkedProcessTaskRunner.init(),
             this.tasksSchedule.init(),
             'init' in this.cache ? this.cache.init() : null,
         ]);
+    }
+    async run() {
+        await this.init();
         // initial scheduling
         await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');
-        const threadCount = this.options.parallel +
-            Object.values(this.taskGraph.tasks).filter((t) => t.continuous).length;
+        const threadCount = getThreadCount(this.options, this.taskGraph);
         const threads = [];
         process.stdout.setMaxListeners(threadCount + events_1.defaultMaxListeners);
         process.stderr.setMaxListeners(threadCount + events_1.defaultMaxListeners);
@@ -63,7 +75,19 @@ class TaskOrchestrator {
         for (let i = 0; i < threadCount; ++i) {
             threads.push(this.executeNextBatchOfTasksUsingTaskSchedule());
         }
-        await Promise.all(threads);
+        await Promise.race([
+            Promise.all(threads),
+            ...(this.tuiEnabled
+                ? [
+                    new Promise((resolve) => {
+                        this.options.lifeCycle.registerForcedShutdownCallback(() => {
+                            // The user force quit the TUI with ctrl+c, so proceed onto cleanup
+                            resolve(undefined);
+                        });
+                    }),
+                ]
+                : []),
+        ]);
         perf_hooks_1.performance.mark('task-execution:end');
         perf_hooks_1.performance.measure('task-execution', 'task-execution:start', 'task-execution:end');
         this.cache.removeOldCacheRecords();
@@ -100,12 +124,20 @@ class TaskOrchestrator {
         // block until some other task completes, then try again
         return new Promise((res) => this.waitingForTasks.push(res)).then(() => this.executeNextBatchOfTasksUsingTaskSchedule());
     }
+    processTasks(taskIds) {
+        for (const taskId of taskIds) {
+            // Task is already handled or being handled
+            if (!this.processedTasks.has(taskId)) {
+                this.processedTasks.set(taskId, this.processTask(taskId));
+            }
+        }
+    }
     // region Processing Scheduled Tasks
-    async processScheduledTask(taskId) {
+    async processTask(taskId) {
         const task = this.taskGraph.tasks[taskId];
         const taskSpecificEnv = (0, task_env_1.getTaskSpecificEnv)(task);
         if (!task.hash) {
-            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, taskSpecificEnv, this.taskDetails);
+            await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraphForHashing, task, taskSpecificEnv, this.taskDetails);
         }
         await this.options.lifeCycle.scheduleTask(task);
         return taskSpecificEnv;
@@ -113,7 +145,7 @@ class TaskOrchestrator {
     async processScheduledBatch(batch) {
         await Promise.all(Object.values(batch.taskGraph.tasks).map(async (task) => {
             if (!task.hash) {
-                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraph, task, this.batchEnv, this.taskDetails);
+                await (0, hash_task_1.hashTask)(this.hasher, this.projectGraph, this.taskGraphForHashing, task, this.batchEnv, this.taskDetails);
             }
             await this.options.lifeCycle.scheduleTask(task);
         }));
@@ -123,12 +155,7 @@ class TaskOrchestrator {
         for (const batch of scheduledBatches) {
             this.processedBatches.set(batch, this.processScheduledBatch(batch));
         }
-        for (const taskId of scheduledTasks) {
-            // Task is already handled or being handled
-            if (!this.processedTasks.has(taskId)) {
-                this.processedTasks.set(taskId, this.processScheduledTask(taskId));
-            }
-        }
+        this.processTasks(scheduledTasks);
     }
     // endregion Processing Scheduled Tasks
     // region Applying Cache
@@ -142,7 +169,12 @@ class TaskOrchestrator {
         if (!cachedResult || cachedResult.code !== 0)
             return null;
         const outputs = task.outputs;
-        const shouldCopyOutputsFromCache = !!outputs.length &&
+        const shouldCopyOutputsFromCache = 
+        // No output files to restore
+        !!outputs.length &&
+            // Remote caches are restored to output dirs when applied and using db cache
+            (!cachedResult.remote || !(0, cache_1.dbCacheEnabled)(this.nxJson)) &&
+            // Output files have not been touched since last run
             (await this.shouldCopyOutputsFromCache(outputs, task.hash));
         if (shouldCopyOutputsFromCache) {
             await this.cache.copyFilesFromCache(task.hash, cachedResult, outputs);
@@ -154,6 +186,7 @@ class TaskOrchestrator {
                 : 'local-cache-kept-existing';
         this.options.lifeCycle.printTaskTerminalOutput(task, status, cachedResult.terminalOutput);
         return {
+            code: cachedResult.code,
             task,
             status,
         };
@@ -177,6 +210,7 @@ class TaskOrchestrator {
             results.push(...batchResults);
         }
         await this.postRunSteps(tasks, results, doNotSkipCache, { groupId });
+        this.forkedProcessTaskRunner.cleanUpBatchProcesses();
         const tasksCompleted = taskEntries.filter(([taskId]) => this.completedTasks[taskId]);
         // Batch is still not done, run it again
         if (tasksCompleted.length !== taskEntries.length) {
@@ -188,7 +222,7 @@ class TaskOrchestrator {
     }
     async runBatch(batch, env) {
         try {
-            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.taskGraph, env);
+            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.projectGraph, this.taskGraph, env);
             const results = await batchProcess.getResults();
             const batchResultEntries = Object.entries(results);
             return batchResultEntries.map(([taskId, result]) => ({
@@ -233,11 +267,13 @@ class TaskOrchestrator {
             const { code, terminalOutput } = await childProcess.getResults();
             results.push({
                 task,
+                code,
                 status: code === 0 ? 'success' : 'failure',
                 terminalOutput,
             });
         }
         await this.postRunSteps([task], results, doNotSkipCache, { groupId });
+        return results[0];
     }
     async runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput) {
         const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
@@ -247,7 +283,6 @@ class TaskOrchestrator {
             !shouldPrefix) {
             try {
                 const { schema } = (0, utils_1.getExecutorForTask)(task, this.projectGraph);
-                const isRunOne = this.initiatingProject != null;
                 const combinedOptions = (0, params_1.combineOptionsForExecutor)(task.overrides, task.target.configuration ?? targetConfiguration.defaultConfiguration, targetConfiguration, schema, task.target.project, (0, path_1.relative)(task.projectRoot ?? workspace_root_1.workspaceRoot, process.cwd()), process.env.NX_VERBOSE_LOGGING === 'true');
                 if (combinedOptions.env) {
                     env = {
@@ -259,22 +294,48 @@ class TaskOrchestrator {
                     const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
                     output_1.output.logCommand(args.join(' '));
                 }
-                const runningTask = await (0, run_commands_impl_1.runCommands)({
+                const runCommandsOptions = {
                     ...combinedOptions,
                     env,
-                    usePty: isRunOne &&
-                        !this.tasksSchedule.hasTasks() &&
-                        this.runningContinuousTasks.size === 0,
+                    usePty: this.tuiEnabled ||
+                        (!this.tasksSchedule.hasTasks() &&
+                            this.runningContinuousTasks.size === 0),
                     streamOutput,
-                }, {
+                };
+                const runningTask = await (0, run_commands_impl_1.runCommands)(runCommandsOptions, {
                     root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
                 });
-                runningTask.onExit((code, terminalOutput) => {
-                    if (!streamOutput) {
-                        this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
-                        (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                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) {
+                        // TODO: shouldn't this be checking if the task is continuous before writing anything to disk or calling printTaskTerminalOutput?
+                        let terminalOutput = '';
+                        runningTask.onOutput((data) => {
+                            terminalOutput += data;
+                        });
+                        runningTask.onExit((code) => {
+                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                            (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                        });
+                    }
+                    else {
+                        runningTask.onExit((code, terminalOutput) => {
+                            this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
+                            (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                        });
+                    }
+                }
                 return runningTask;
             }
             catch (e) {
@@ -286,6 +347,10 @@ class TaskOrchestrator {
                 }
                 const terminalOutput = e.stack ?? e.message ?? '';
                 (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                return new noop_child_process_1.NoopChildProcess({
+                    code: 1,
+                    terminalOutput,
+                });
             }
         }
         else if (targetConfiguration.executor === 'nx:noop') {
@@ -297,14 +362,27 @@ class TaskOrchestrator {
         }
         else {
             // cache prep
-            return await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+            const runningTask = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+            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;
         }
     }
     async runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput) {
         try {
             const usePtyFork = process.env.NX_NATIVE_COMMAND_RUNNER !== 'false';
             // Disable the pseudo terminal if this is a run-many or when running a continuous task as part of a run-one
-            const disablePseudoTerminal = !this.initiatingProject || task.continuous;
+            const disablePseudoTerminal = !this.tuiEnabled && (!this.initiatingProject || task.continuous);
             // execution
             const childProcess = usePtyFork
                 ? await this.forkedProcessTaskRunner.forkProcess(task, {
@@ -335,6 +413,36 @@ class TaskOrchestrator {
         }
     }
     async startContinuousTask(task, groupId) {
+        if (this.runningTasksService.getRunningTasks([task.id]).length) {
+            await this.preRunSteps([task], { groupId });
+            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(() => {
+                if (this.tuiEnabled) {
+                    this.options.lifeCycle.setTaskStatus(task.id, 9 /* NativeTaskStatus.Stopped */);
+                }
+                this.runningContinuousTasks.delete(task.id);
+            });
+            // task is already running by another process, we schedule the next tasks
+            // and release the threads
+            await this.scheduleNextTasksAndReleaseThreads();
+            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 });
         const pipeOutput = await this.pipeOutputCapture(task);
@@ -349,25 +457,27 @@ class TaskOrchestrator {
                 : process.env.FORCE_COLOR, this.options.skipNxCache, this.options.captureStderr, null, null)
             : (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, undefined, this.options.skipNxCache, this.options.captureStderr, temporaryOutputPath, streamOutput);
         const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
+        this.runningTasksService.addRunningTask(task.id);
         this.runningContinuousTasks.set(task.id, childProcess);
-        childProcess.onExit((code) => {
-            if (!this.cleaningUp) {
-                console.error(`Task "${task.id}" is continuous but exited with code ${code}`);
-                this.cleanup().then(() => {
-                    process.exit(1);
-                });
+        childProcess.onExit(() => {
+            if (this.tuiEnabled) {
+                this.options.lifeCycle.setTaskStatus(task.id, 9 /* NativeTaskStatus.Stopped */);
             }
+            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.tasksSchedule.scheduleNextTasks();
-            // release blocked threads
-            this.waitingForTasks.forEach((f) => f(null));
-            this.waitingForTasks.length = 0;
+        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;
     }
@@ -430,6 +540,9 @@ class TaskOrchestrator {
                 status,
             };
         }));
+        await this.scheduleNextTasksAndReleaseThreads();
+    }
+    async scheduleNextTasksAndReleaseThreads() {
         await this.tasksSchedule.scheduleNextTasks();
         // release blocked threads
         this.waitingForTasks.forEach((f) => f(null));
@@ -437,9 +550,13 @@ 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;
+                if (this.tuiEnabled) {
+                    this.options.lifeCycle.setTaskStatus(taskId, (0, native_1.parseTaskStatus)(status));
+                }
                 if (status === 'failure' || status === 'skipped') {
                     if (this.bail) {
                         // mark the execution as bailed which will stop all further execution
@@ -503,15 +620,53 @@ 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);
             }
+            finally {
+                this.runningTasksService.removeRunningTask(taskId);
+            }
         }));
     }
+    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) {
+    if (options['parallel'] === 'false' ||
+        options['parallel'] === false) {
+        options['parallel'] = 1;
+    }
+    else if (options['parallel'] === 'true' ||
+        options['parallel'] === true ||
+        options['parallel'] === undefined ||
+        options['parallel'] === '') {
+        options['parallel'] = Number(options['maxParallel'] || 3);
+    }
+    const maxParallel = options['parallel'] +
+        Object.values(taskGraph.tasks).filter((t) => t.continuous).length;
+    const totalTasks = Object.keys(taskGraph.tasks).length;
+    return Math.min(maxParallel, totalTasks);
+}

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.d.ts

@@ -1,7 +1,7 @@
-import { Task, TaskGraph } from '../config/task-graph';
+import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
 import { TargetConfiguration, TargetDependencyConfig } from '../config/workspace-json-project-json';
-import { CustomHasher, ExecutorConfig } from '../config/misc-interfaces';
 export type NormalizedTargetDependencyConfig = TargetDependencyConfig & {
     projects: string[];
 };