nx 19.7.4 → 19.8.0-beta.0

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = runCommand;
+exports.runCommandForTasks = runCommandForTasks;
 exports.invokeTasksRunner = invokeTasksRunner;
 exports.getRunner = getRunner;
 exports.getRunnerOptions = getRunnerOptions;
@@ -31,6 +32,7 @@ const task_history_life_cycle_1 = require("./life-cycles/task-history-life-cycle
 const task_history_life_cycle_old_1 = require("./life-cycles/task-history-life-cycle-old");
 const task_profiling_life_cycle_1 = require("./life-cycles/task-profiling-life-cycle");
 const task_timings_life_cycle_1 = require("./life-cycles/task-timings-life-cycle");
+const task_results_life_cycle_1 = require("./life-cycles/task-results-life-cycle");
 const task_graph_utils_1 = require("./task-graph-utils");
 const utils_1 = require("./utils");
 const chalk = require("chalk");
@@ -99,25 +101,31 @@ function createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies,
 }
 async function runCommand(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
     const status = await (0, handle_errors_1.handleErrors)(process.env.NX_VERBOSE_LOGGING === 'true', async () => {
-        const projectNames = projectsToRun.map((t) => t.name);
-        const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
-        const tasks = Object.values(taskGraph.tasks);
-        const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
-        const status = await invokeTasksRunner({
-            tasks,
-            projectGraph,
-            taskGraph,
-            lifeCycle,
-            nxJson,
-            nxArgs,
-            loadDotEnvFiles: extraOptions.loadDotEnvFiles,
-            initiatingProject,
-        });
-        await renderIsDone;
-        return status;
+        const taskResults = await runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions);
+        return Object.values(taskResults).some((taskResult) => taskResult.status === 'failure' || taskResult.status === 'skipped')
+            ? 1
+            : 0;
     });
     return status;
 }
+async function runCommandForTasks(projectsToRun, currentProjectGraph, { nxJson }, nxArgs, overrides, initiatingProject, extraTargetDependencies, extraOptions) {
+    const projectNames = projectsToRun.map((t) => t.name);
+    const { projectGraph, taskGraph } = await ensureWorkspaceIsInSyncAndGetGraphs(currentProjectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions);
+    const tasks = Object.values(taskGraph.tasks);
+    const { lifeCycle, renderIsDone } = await getTerminalOutputLifeCycle(initiatingProject, projectNames, tasks, nxArgs, nxJson, overrides);
+    const taskResults = await invokeTasksRunner({
+        tasks,
+        projectGraph,
+        taskGraph,
+        lifeCycle,
+        nxJson,
+        nxArgs,
+        loadDotEnvFiles: extraOptions.loadDotEnvFiles,
+        initiatingProject,
+    });
+    await renderIsDone;
+    return taskResults;
+}
 async function ensureWorkspaceIsInSyncAndGetGraphs(projectGraph, nxJson, projectNames, nxArgs, overrides, extraTargetDependencies, extraOptions) {
     let taskGraph = createTaskGraphAndRunValidations(projectGraph, extraTargetDependencies ?? {}, projectNames, nxArgs, overrides, extraOptions);
     if (nxArgs.skipSync) {
@@ -359,9 +367,14 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
     // to submit everything that is known in advance to Nx Cloud to run in
     // a distributed fashion
     await (0, hash_task_1.hashTasksThatDoNotDependOnOutputsOfOtherTasks)(hasher, projectGraph, taskGraph, nxJson);
-    const promiseOrObservable = tasksRunner(tasks, {
+    const taskResultsLifecycle = new task_results_life_cycle_1.TaskResultsLifeCycle();
+    const compositedLifeCycle = new life_cycle_1.CompositeLifeCycle([
+        ...constructLifeCycles(lifeCycle),
+        taskResultsLifecycle,
+    ]);
+    let promiseOrObservable = tasksRunner(tasks, {
         ...runnerOptions,
-        lifeCycle: new life_cycle_1.CompositeLifeCycle(constructLifeCycles(lifeCycle)),
+        lifeCycle: compositedLifeCycle,
     }, {
         initiatingProject: nxArgs.outputStyle === 'compact' ? null : initiatingProject,
         projectGraph,
@@ -418,15 +431,11 @@ async function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nx
         },
         daemon: client_1.daemonClient,
     });
-    let anyFailures;
     if (promiseOrObservable.subscribe) {
-        anyFailures = await anyFailuresInObservable(promiseOrObservable);
-    }
-    else {
-        // simply await the promise
-        anyFailures = await anyFailuresInPromise(promiseOrObservable);
+        promiseOrObservable = convertObservableToPromise(promiseOrObservable);
     }
-    return anyFailures ? 1 : 0;
+    await promiseOrObservable;
+    return taskResultsLifecycle.getTaskResults();
 }
 function constructLifeCycles(lifeCycle) {
     const lifeCycles = [];
@@ -445,41 +454,23 @@ function constructLifeCycles(lifeCycle) {
     }
     return lifeCycles;
 }
-function mergeTargetDependencies(defaults, deps) {
-    const res = {};
-    Object.keys(defaults ?? {}).forEach((k) => {
-        res[k] = defaults[k].dependsOn;
-    });
-    if (deps) {
-        Object.keys(deps).forEach((k) => {
-            if (res[k]) {
-                res[k] = [...res[k], deps[k]];
-            }
-            else {
-                res[k] = deps[k];
-            }
-        });
-        return res;
-    }
-}
-async function anyFailuresInPromise(promise) {
-    return Object.values(await promise).some((v) => v === 'failure' || v === 'skipped');
-}
-async function anyFailuresInObservable(obs) {
+async function convertObservableToPromise(obs) {
     return await new Promise((res) => {
-        let anyFailures = false;
-        obs.subscribe((t) => {
-            if (!t.success) {
-                anyFailures = true;
-            }
-        }, (error) => {
-            output_1.output.error({
-                title: 'Unhandled error in task executor',
-            });
-            console.error(error);
-            res(true);
-        }, () => {
-            res(anyFailures);
+        let tasksResults = {};
+        obs.subscribe({
+            next: (t) => {
+                tasksResults[t.task.id] = t.success ? 'success' : 'failure';
+            },
+            error: (error) => {
+                output_1.output.error({
+                    title: 'Unhandled error in task executor',
+                });
+                console.error(error);
+                res(tasksResults);
+            },
+            complete: () => {
+                res(tasksResults);
+            },
         });
     });
 }

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

@@ -41,7 +41,10 @@ class TaskOrchestrator {
     }
     async run() {
         // Init the ForkedProcessTaskRunner
-        await this.forkedProcessTaskRunner.init();
+        await Promise.all([
+            this.forkedProcessTaskRunner.init(),
+            this.tasksSchedule.init(),
+        ]);
         // initial scheduling
         await this.tasksSchedule.scheduleNextTasks();
         perf_hooks_1.performance.mark('task-execution:start');

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

@@ -12,12 +12,15 @@ export declare class TasksSchedule {
     private notScheduledTaskGraph;
     private reverseTaskDeps;
     private reverseProjectGraph;
+    private taskHistory;
     private scheduledBatches;
     private scheduledTasks;
     private runningTasks;
     private completedTasks;
     private scheduleRequestsExecutionChain;
+    private estimatedTaskTimings;
     constructor(projectGraph: ProjectGraph, taskGraph: TaskGraph, options: DefaultTasksRunnerOptions);
+    init(): Promise<void>;
     scheduleNextTasks(): Promise<void>;
     hasTasks(): boolean;
     complete(taskIds: string[]): void;

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

@@ -4,6 +4,7 @@ exports.TasksSchedule = void 0;
 const utils_1 = require("./utils");
 const project_graph_utils_1 = require("../utils/project-graph-utils");
 const operators_1 = require("../project-graph/operators");
+const task_history_1 = require("../utils/task-history");
 class TasksSchedule {
     constructor(projectGraph, taskGraph, options) {
         this.projectGraph = projectGraph;
@@ -12,11 +13,19 @@ class TasksSchedule {
         this.notScheduledTaskGraph = this.taskGraph;
         this.reverseTaskDeps = (0, utils_1.calculateReverseDeps)(this.taskGraph);
         this.reverseProjectGraph = (0, operators_1.reverse)(this.projectGraph);
+        this.taskHistory = process.env.NX_DISABLE_DB !== 'true' ? (0, task_history_1.getTaskHistory)() : null;
         this.scheduledBatches = [];
         this.scheduledTasks = [];
         this.runningTasks = new Set();
         this.completedTasks = new Set();
         this.scheduleRequestsExecutionChain = Promise.resolve();
+        this.estimatedTaskTimings = {};
+    }
+    async init() {
+        if (this.taskHistory) {
+            this.estimatedTaskTimings =
+                await this.taskHistory.getEstimatedTaskTimings(Object.values(this.taskGraph.tasks).map((t) => t.target));
+        }
     }
     async scheduleNextTasks() {
         this.scheduleRequestsExecutionChain =
@@ -81,10 +90,23 @@ class TasksSchedule {
             // Most likely tasks with no dependencies such as test
             const project1 = this.taskGraph.tasks[taskId1].target.project;
             const project2 = this.taskGraph.tasks[taskId2].target.project;
-            return ((0, project_graph_utils_1.findAllProjectNodeDependencies)(project2, this.reverseProjectGraph)
-                .length -
-                (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph)
-                    .length);
+            const project1NodeDependencies = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project1, this.reverseProjectGraph).length;
+            const project2NodeDependencies = (0, project_graph_utils_1.findAllProjectNodeDependencies)(project2, this.reverseProjectGraph).length;
+            const dependenciesDiff = project2NodeDependencies - project1NodeDependencies;
+            if (dependenciesDiff !== 0) {
+                return dependenciesDiff;
+            }
+            const task1Timing = this.estimatedTaskTimings[taskId1];
+            if (!task1Timing) {
+                // if no timing or 0, put task1 at beginning
+                return -1;
+            }
+            const task2Timing = this.estimatedTaskTimings[taskId2];
+            if (!task2Timing) {
+                // if no timing or 0, put task2 at beginning
+                return 1;
+            }
+            return task2Timing - task1Timing;
         });
         this.runningTasks.add(taskId);
     }

package/src/utils/git-utils.d.ts

@@ -7,6 +7,7 @@ export declare class GitRepository {
     root: string;
     constructor(directory: string);
     getGitRootPath(cwd: string): string;
+    hasUncommittedChanges(): Promise<boolean>;
     addFetchRemote(remoteName: string, branch: string): Promise<string>;
     showStat(): Promise<string>;
     listBranches(): Promise<string[]>;

package/src/utils/git-utils.js

@@ -40,6 +40,10 @@ class GitRepository {
             .toString()
             .trim();
     }
+    async hasUncommittedChanges() {
+        const data = await this.execAsync(`git status --porcelain`);
+        return data.trim() !== '';
+    }
     async addFetchRemote(remoteName, branch) {
         return await this.execAsync(`git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`);
     }

package/src/utils/task-history.d.ts

@@ -1,6 +1,17 @@
-import { NxTaskHistory, TaskRun } from '../native';
+import { NxTaskHistory, TaskRun, TaskTarget } from '../native';
 export declare class TaskHistory {
     taskHistory: NxTaskHistory;
+    /**
+     * This function returns estimated timings per task
+     * @param targets
+     * @returns a map where key is task id (project:target:configuration), value is average time of historical runs
+     */
+    getEstimatedTaskTimings(targets: TaskTarget[]): Promise<Record<string, number>>;
     getFlakyTasks(hashes: string[]): Promise<string[]>;
     recordTaskRuns(taskRuns: TaskRun[]): Promise<void>;
 }
+/**
+ * This function returns the singleton instance of TaskHistory
+ * @returns singleton instance of TaskHistory
+ */
+export declare function getTaskHistory(): TaskHistory;

package/src/utils/task-history.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskHistory = void 0;
+exports.getTaskHistory = getTaskHistory;
 const client_1 = require("../daemon/client/client");
 const is_on_daemon_1 = require("../daemon/is-on-daemon");
 const native_1 = require("../native");
@@ -9,6 +10,17 @@ class TaskHistory {
     constructor() {
         this.taskHistory = new native_1.NxTaskHistory((0, db_connection_1.getDbConnection)());
     }
+    /**
+     * This function returns estimated timings per task
+     * @param targets
+     * @returns a map where key is task id (project:target:configuration), value is average time of historical runs
+     */
+    async getEstimatedTaskTimings(targets) {
+        if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
+            return this.taskHistory.getEstimatedTaskTimings(targets);
+        }
+        return await client_1.daemonClient.getEstimatedTaskTimings(targets);
+    }
     async getFlakyTasks(hashes) {
         if ((0, is_on_daemon_1.isOnDaemon)() || !client_1.daemonClient.enabled()) {
             return this.taskHistory.getFlakyTasks(hashes);
@@ -23,3 +35,14 @@ class TaskHistory {
     }
 }
 exports.TaskHistory = TaskHistory;
+let taskHistory;
+/**
+ * This function returns the singleton instance of TaskHistory
+ * @returns singleton instance of TaskHistory
+ */
+function getTaskHistory() {
+    if (!taskHistory) {
+        taskHistory = new TaskHistory();
+    }
+    return taskHistory;
+}