nx 21.0.0-beta.3 → 21.0.0-beta.5

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

@@ -7,9 +7,11 @@ 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;
@@ -26,6 +28,7 @@ export declare class TaskOrchestrator {
     private tasksSchedule;
     private batchEnv;
     private reverseTaskDeps;
+    private initializingTaskIds;
     private processedTasks;
     private processedBatches;
     private completedTasks;
@@ -33,8 +36,7 @@ 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, taskGraphForHashing?: TaskGraph);
+    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;
@@ -55,7 +57,7 @@ export declare class TaskOrchestrator {
     }>;
     private runTask;
     private runTaskInForkedProcess;
-    startContinuousTask(task: Task, groupId: number): Promise<RunningTask>;
+    startContinuousTask(task: Task, groupId: number): Promise<RunningTask | SharedRunningTask>;
     private preRunSteps;
     private postRunSteps;
     private scheduleNextTasksAndReleaseThreads;
@@ -67,5 +69,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

@@ -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
@@ -75,12 +77,16 @@ class TaskOrchestrator {
         }
         await Promise.race([
             Promise.all(threads),
-            new Promise((resolve) => {
-                this.options.lifeCycle.registerForcedShutdownCallback(() => {
-                    // The user force quit the TUI with ctrl+c, so proceed onto cleanup
-                    resolve(undefined);
-                });
-            }),
+            ...(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');
@@ -393,15 +399,19 @@ 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)) {
+                // Hold the thread forever
+                await new Promise(() => { });
+            }
+            return runningTask;
         }
         const taskSpecificEnv = await this.processedTasks.get(task.id);
         await this.preRunSteps([task], { groupId });
@@ -421,14 +431,12 @@ 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)) {
+            // Hold the thread forever
+            await new Promise(() => { });
         }
         return childProcess;
     }
@@ -501,6 +509,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;
@@ -567,10 +576,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);
@@ -580,6 +589,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/utils/git-utils.d.ts

@@ -38,4 +38,4 @@ export declare class GitRepository {
 export declare function getGithubSlugOrNull(): string | null;
 export declare function extractUserAndRepoFromGitHubUrl(gitRemotes: string): string | null;
 export declare function commitChanges(commitMessage: string, directory?: string): string | null;
-export declare function getLatestCommitSha(): string | null;
+export declare function getLatestCommitSha(directory?: string): string | null;

package/src/utils/git-utils.js

@@ -222,7 +222,11 @@ function parseGitHubUrl(url) {
 }
 function commitChanges(commitMessage, directory) {
     try {
-        (0, child_process_1.execSync)('git add -A', { encoding: 'utf8', stdio: 'pipe' });
+        (0, child_process_1.execSync)('git add -A', {
+            encoding: 'utf8',
+            stdio: 'pipe',
+            cwd: directory,
+        });
         (0, child_process_1.execSync)('git commit --no-verify -F -', {
             encoding: 'utf8',
             stdio: 'pipe',
@@ -243,14 +247,15 @@ function commitChanges(commitMessage, directory) {
             throw new Error(`Error committing changes:\n${err.stderr}`);
         }
     }
-    return getLatestCommitSha();
+    return getLatestCommitSha(directory);
 }
-function getLatestCommitSha() {
+function getLatestCommitSha(directory) {
     try {
         return (0, child_process_1.execSync)('git rev-parse HEAD', {
             encoding: 'utf8',
             stdio: 'pipe',
             windowsHide: false,
+            cwd: directory,
         }).trim();
     }
     catch {