nx 21.0.0-beta.1 → 21.0.0-canary.20250206-8bd0bcd

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

@@ -15,7 +15,6 @@ const task_env_1 = require("./task-env");
 const workspace_root_1 = require("../utils/workspace-root");
 const output_1 = require("../utils/output");
 const params_1 = require("../utils/params");
-const noop_child_process_1 = require("./running-tasks/noop-child-process");
 class TaskOrchestrator {
     // endregion internal state
     constructor(hasher, initiatingProject, projectGraph, taskGraph, nxJson, options, bail, daemon, outputStyle) {
@@ -41,8 +40,6 @@ class TaskOrchestrator {
         this.waitingForTasks = [];
         this.groups = [];
         this.bailed = false;
-        this.runningContinuousTasks = new Map();
-        this.cleaningUp = false;
     }
     async run() {
         // Init the ForkedProcessTaskRunner, TasksSchedule, and Cache
@@ -54,20 +51,17 @@ class TaskOrchestrator {
         // 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 threads = [];
-        process.stdout.setMaxListeners(threadCount + events_1.defaultMaxListeners);
-        process.stderr.setMaxListeners(threadCount + events_1.defaultMaxListeners);
+        process.stdout.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
+        process.stderr.setMaxListeners(this.options.parallel + events_1.defaultMaxListeners);
         // initial seeding of the queue
-        for (let i = 0; i < threadCount; ++i) {
+        for (let i = 0; i < this.options.parallel; ++i) {
             threads.push(this.executeNextBatchOfTasksUsingTaskSchedule());
         }
         await Promise.all(threads);
         perf_hooks_1.performance.mark('task-execution:end');
         perf_hooks_1.performance.measure('task-execution', 'task-execution:start', 'task-execution:end');
         this.cache.removeOldCacheRecords();
-        await this.cleanup();
         return this.completedTasks;
     }
     async executeNextBatchOfTasksUsingTaskSchedule() {
@@ -88,12 +82,7 @@ class TaskOrchestrator {
         const task = this.tasksSchedule.nextTask();
         if (task) {
             const groupId = this.closeGroup();
-            if (task.continuous) {
-                await this.startContinuousTask(task, groupId);
-            }
-            else {
-                await this.applyFromCacheOrRunTask(doNotSkipCache, task, groupId);
-            }
+            await this.applyFromCacheOrRunTask(doNotSkipCache, task, groupId);
             this.openGroup(groupId);
             return this.executeNextBatchOfTasksUsingTaskSchedule();
         }
@@ -188,8 +177,7 @@ class TaskOrchestrator {
     }
     async runBatch(batch, env) {
         try {
-            const batchProcess = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.taskGraph, env);
-            const results = await batchProcess.getResults();
+            const results = await this.forkedProcessTaskRunner.forkProcessForBatch(batch, this.taskGraph, env);
             const batchResultEntries = Object.entries(results);
             return batchResultEntries.map(([taskId, result]) => ({
                 ...result,
@@ -229,84 +217,88 @@ class TaskOrchestrator {
         let results = doNotSkipCache ? await this.applyCachedResults([task]) : [];
         // the task wasn't cached
         if (results.length === 0) {
-            const childProcess = await this.runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput);
-            const { code, terminalOutput } = await childProcess.getResults();
-            results.push({
-                task,
-                status: code === 0 ? 'success' : 'failure',
-                terminalOutput,
-            });
-        }
-        await this.postRunSteps([task], results, doNotSkipCache, { groupId });
-    }
-    async runTask(task, streamOutput, env, temporaryOutputPath, pipeOutput) {
-        const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
-        const targetConfiguration = (0, utils_1.getTargetConfigurationForTask)(task, this.projectGraph);
-        if (process.env.NX_RUN_COMMANDS_DIRECTLY !== 'false' &&
-            targetConfiguration.executor === 'nx:run-commands' &&
-            !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 = {
-                        ...env,
-                        ...combinedOptions.env,
-                    };
-                }
-                if (streamOutput) {
-                    const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
-                    output_1.output.logCommand(args.join(' '));
-                }
-                const runningTask = await (0, run_commands_impl_1.runCommands)({
-                    ...combinedOptions,
-                    env,
-                    usePty: isRunOne &&
-                        !this.tasksSchedule.hasTasks() &&
-                        this.runningContinuousTasks.size === 0,
-                    streamOutput,
-                }, {
-                    root: workspace_root_1.workspaceRoot, // only root is needed in runCommands
-                });
-                runningTask.onExit((code, terminalOutput) => {
+            const shouldPrefix = streamOutput && process.env.NX_PREFIX_OUTPUT === 'true';
+            const targetConfiguration = (0, utils_1.getTargetConfigurationForTask)(task, this.projectGraph);
+            if (process.env.NX_RUN_COMMANDS_DIRECTLY !== 'false' &&
+                targetConfiguration.executor === 'nx:run-commands' &&
+                !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 = {
+                            ...env,
+                            ...combinedOptions.env,
+                        };
+                    }
+                    if (streamOutput) {
+                        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+                        output_1.output.logCommand(args.join(' '));
+                    }
+                    const { success, terminalOutput } = await (0, run_commands_impl_1.default)({
+                        ...combinedOptions,
+                        env,
+                        usePty: isRunOne && !this.tasksSchedule.hasTasks(),
+                        streamOutput,
+                    }, {
+                        root: workspace_root_1.workspaceRoot, // only root is needed in runCommandsImpl
+                    });
+                    const status = success ? 'success' : 'failure';
                     if (!streamOutput) {
-                        this.options.lifeCycle.printTaskTerminalOutput(task, code === 0 ? 'success' : 'failure', terminalOutput);
-                        (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                        this.options.lifeCycle.printTaskTerminalOutput(task, status, terminalOutput);
                     }
-                });
-                return runningTask;
-            }
-            catch (e) {
-                if (process.env.NX_VERBOSE_LOGGING === 'true') {
-                    console.error(e);
+                    (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                    results.push({
+                        task,
+                        status,
+                        terminalOutput,
+                    });
                 }
-                else {
-                    console.error(e.message);
+                catch (e) {
+                    if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                        console.error(e);
+                    }
+                    else {
+                        console.error(e.message);
+                    }
+                    const terminalOutput = e.stack ?? e.message ?? '';
+                    (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+                    results.push({
+                        task,
+                        status: 'failure',
+                        terminalOutput,
+                    });
                 }
-                const terminalOutput = e.stack ?? e.message ?? '';
-                (0, fs_1.writeFileSync)(temporaryOutputPath, terminalOutput);
+            }
+            else if (targetConfiguration.executor === 'nx:noop') {
+                (0, fs_1.writeFileSync)(temporaryOutputPath, '');
+                results.push({
+                    task,
+                    status: 'success',
+                    terminalOutput: '',
+                });
+            }
+            else {
+                // cache prep
+                const { code, terminalOutput } = await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
+                results.push({
+                    task,
+                    status: code === 0 ? 'success' : 'failure',
+                    terminalOutput,
+                });
             }
         }
-        else if (targetConfiguration.executor === 'nx:noop') {
-            (0, fs_1.writeFileSync)(temporaryOutputPath, '');
-            return new noop_child_process_1.NoopChildProcess({
-                code: 0,
-                terminalOutput: '',
-            });
-        }
-        else {
-            // cache prep
-            return await this.runTaskInForkedProcess(task, env, pipeOutput, temporaryOutputPath, streamOutput);
-        }
+        await this.postRunSteps([task], results, doNotSkipCache, { groupId });
     }
     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;
+            // Disable the pseudo terminal if this is a run-many
+            const disablePseudoTerminal = !this.initiatingProject;
             // execution
-            const childProcess = usePtyFork
+            const { code, terminalOutput } = usePtyFork
                 ? await this.forkedProcessTaskRunner.forkProcess(task, {
                     temporaryOutputPath,
                     streamOutput,
@@ -322,54 +314,19 @@ class TaskOrchestrator {
                     taskGraph: this.taskGraph,
                     env,
                 });
-            return childProcess;
+            return {
+                code,
+                terminalOutput,
+            };
         }
         catch (e) {
             if (process.env.NX_VERBOSE_LOGGING === 'true') {
                 console.error(e);
             }
-            return new noop_child_process_1.NoopChildProcess({
+            return {
                 code: 1,
-                terminalOutput: undefined,
-            });
-        }
-    }
-    async startContinuousTask(task, groupId) {
-        const taskSpecificEnv = await this.processedTasks.get(task.id);
-        await this.preRunSteps([task], { groupId });
-        const pipeOutput = await this.pipeOutputCapture(task);
-        // obtain metadata
-        const temporaryOutputPath = this.cache.temporaryOutputPath(task);
-        const streamOutput = this.outputStyle === 'static'
-            ? false
-            : (0, utils_1.shouldStreamOutput)(task, this.initiatingProject);
-        let env = pipeOutput
-            ? (0, task_env_1.getEnvVariablesForTask)(task, taskSpecificEnv, process.env.FORCE_COLOR === undefined
-                ? 'true'
-                : 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.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);
-                });
-            }
-        });
-        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;
+            };
         }
-        return childProcess;
     }
     // endregion Single Task
     // region Lifecycle
@@ -501,17 +458,5 @@ class TaskOrchestrator {
             return this.daemon.recordOutputsHash(task.outputs, task.hash);
         }
     }
-    // endregion utils
-    async cleanup() {
-        this.cleaningUp = true;
-        await Promise.all(Array.from(this.runningContinuousTasks).map(async ([taskId, t]) => {
-            try {
-                return t.kill();
-            }
-            catch (e) {
-                console.error(`Unable to terminate ${taskId}\nError:`, e);
-            }
-        }));
-    }
 }
 exports.TaskOrchestrator = TaskOrchestrator;

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

@@ -147,14 +147,11 @@ class TasksSchedule {
                 {
                     tasks: {},
                     dependencies: {},
-                    continuousDependencies: {},
                     roots: [],
                 });
         batch.tasks[task.id] = task;
         batch.dependencies[task.id] =
             this.notScheduledTaskGraph.dependencies[task.id];
-        batch.continuousDependencies[task.id] =
-            this.notScheduledTaskGraph.continuousDependencies[task.id];
         if (isRoot) {
             batch.roots.push(task.id);
         }
@@ -171,9 +168,8 @@ class TasksSchedule {
     }
     canBeScheduled(taskId) {
         const hasDependenciesCompleted = this.taskGraph.dependencies[taskId].every((id) => this.completedTasks.has(id));
-        const hasContinuousDependenciesStarted = this.taskGraph.continuousDependencies[taskId].every((id) => this.runningTasks.has(id));
         // if dependencies have not completed, cannot schedule
-        if (!hasDependenciesCompleted || !hasContinuousDependenciesStarted) {
+        if (!hasDependenciesCompleted) {
             return false;
         }
         // if there are no running tasks, can schedule anything

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

@@ -37,6 +37,14 @@ export declare function getExecutorForTask(task: Task, projectGraph: ProjectGrap
 };
 export declare function getCustomHasher(task: Task, projectGraph: ProjectGraph): CustomHasher | null;
 export declare function removeTasksFromTaskGraph(graph: TaskGraph, ids: string[]): TaskGraph;
+export declare function removeIdsFromGraph<T>(graph: {
+    roots: string[];
+    dependencies: Record<string, string[]>;
+}, ids: string[], mapWithIds: Record<string, T>): {
+    mapWithIds: Record<string, T>;
+    roots: string[];
+    dependencies: Record<string, string[]>;
+};
 export declare function calculateReverseDeps(taskGraph: TaskGraph): Record<string, string[]>;
 export declare function getCliPath(): string;
 export declare function getPrintableCommandArgsForTask(task: Task): string[];

package/src/tasks-runner/utils.js

@@ -17,6 +17,7 @@ exports.getExecutorNameForTask = getExecutorNameForTask;
 exports.getExecutorForTask = getExecutorForTask;
 exports.getCustomHasher = getCustomHasher;
 exports.removeTasksFromTaskGraph = removeTasksFromTaskGraph;
+exports.removeIdsFromGraph = removeIdsFromGraph;
 exports.calculateReverseDeps = calculateReverseDeps;
 exports.getCliPath = getCliPath;
 exports.getPrintableCommandArgsForTask = getPrintableCommandArgsForTask;
@@ -301,31 +302,27 @@ function getCustomHasher(task, projectGraph) {
     return factory ? factory() : null;
 }
 function removeTasksFromTaskGraph(graph, ids) {
-    const newGraph = removeIdsFromTaskGraph(graph, ids, graph.tasks);
+    const newGraph = removeIdsFromGraph(graph, ids, graph.tasks);
     return {
         dependencies: newGraph.dependencies,
-        continuousDependencies: newGraph.continuousDependencies,
         roots: newGraph.roots,
         tasks: newGraph.mapWithIds,
     };
 }
-function removeIdsFromTaskGraph(graph, ids, mapWithIds) {
+function removeIdsFromGraph(graph, ids, mapWithIds) {
     const filteredMapWithIds = {};
     const dependencies = {};
-    const continuousDependencies = {};
     const removedSet = new Set(ids);
     for (let id of Object.keys(mapWithIds)) {
         if (!removedSet.has(id)) {
             filteredMapWithIds[id] = mapWithIds[id];
             dependencies[id] = graph.dependencies[id].filter((depId) => !removedSet.has(depId));
-            continuousDependencies[id] = graph.continuousDependencies[id].filter((depId) => !removedSet.has(depId));
         }
     }
     return {
         mapWithIds: filteredMapWithIds,
         dependencies: dependencies,
-        continuousDependencies,
-        roots: Object.keys(filteredMapWithIds).filter((k) => dependencies[k].length === 0 && continuousDependencies[k].length === 0),
+        roots: Object.keys(dependencies).filter((k) => dependencies[k].length === 0),
     };
 }
 function calculateReverseDeps(taskGraph) {
@@ -338,11 +335,6 @@ function calculateReverseDeps(taskGraph) {
             reverseTaskDeps[d].push(taskId);
         });
     });
-    Object.keys(taskGraph.continuousDependencies).forEach((taskId) => {
-        taskGraph.continuousDependencies[taskId].forEach((d) => {
-            reverseTaskDeps[d].push(taskId);
-        });
-    });
     return reverseTaskDeps;
 }
 function getCliPath() {

package/src/executors/run-commands/running-tasks.d.ts

@@ -1,38 +0,0 @@
-import { Serializable } from 'child_process';
-import { RunningTask } from '../../tasks-runner/running-tasks/running-task';
-import { ExecutorContext } from '../../config/misc-interfaces';
-import { NormalizedRunCommandsOptions } from './run-commands.impl';
-import { PseudoTerminal } from '../../tasks-runner/pseudo-terminal';
-export declare class ParallelRunningTasks implements RunningTask {
-    private readonly childProcesses;
-    private readyWhenStatus;
-    private readonly streamOutput;
-    private exitCallbacks;
-    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext);
-    getResults(): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
-    onExit(cb: (code: number, terminalOutput: string) => void): void;
-    send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): Promise<void>;
-    private run;
-}
-export declare class SeriallyRunningTasks implements RunningTask {
-    private pseudoTerminal?;
-    private terminalOutput;
-    private currentProcess;
-    private exitCallbacks;
-    private code;
-    private error;
-    constructor(options: NormalizedRunCommandsOptions, context: ExecutorContext, pseudoTerminal?: PseudoTerminal);
-    getResults(): Promise<{
-        code: number;
-        terminalOutput: string;
-    }>;
-    onExit(cb: (code: number, terminalOutput: string) => void): void;
-    send(message: Serializable): void;
-    kill(signal?: NodeJS.Signals | number): void | Promise<void>;
-    private run;
-    private createProcess;
-}