@ohos-ports/nx 19.8.4-beta.0

package/src/tasks-runner/life-cycles/static-run-one-terminal-output-life-cycle.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRunOneTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+const formatting_utils_1 = require("./formatting-utils");
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+class StaticRunOneTerminalOutputLifeCycle {
+    constructor(initiatingProject, projectNames, tasks, args) {
+        this.initiatingProject = initiatingProject;
+        this.projectNames = projectNames;
+        this.tasks = tasks;
+        this.args = args;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+    }
+    startCommand() {
+        const numberOfDeps = this.tasks.length - 1;
+        const title = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}:`;
+        if (numberOfDeps > 0) {
+            output_1.output.log({
+                color: 'cyan',
+                title,
+            });
+            output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+        }
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            const bodyLines = this.cachedTasks.length > 0
+                ? [
+                    output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
+                ]
+                : [];
+            output_1.output.success({
+                title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
+                bodyLines,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            const bodyLines = [
+                output_1.output.dim('Failed tasks:'),
+                '',
+                ...this.failedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`),
+                '',
+                `${output_1.output.dim('Hint: run the command with')} --verbose ${output_1.output.dim('for more details.')}`,
+            ];
+            output_1.output.error({
+                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
+                bodyLines,
+            });
+        }
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, status, terminalOutput) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        if (this.args.verbose ||
+            status === 'success' ||
+            status === 'failure' ||
+            task.target.project === this.initiatingProject) {
+            output_1.output.logCommandOutput(args.join(' '), status, terminalOutput);
+        }
+        else {
+            /**
+             * Do not show the terminal output in the case where it is not the initiating project and verbose is not set,
+             * but still print the command that was run and its status (so that cache hits can still be traced).
+             */
+            output_1.output.logCommandOutput(args.join(' '), status, '');
+        }
+    }
+}
+exports.StaticRunOneTerminalOutputLifeCycle = StaticRunOneTerminalOutputLifeCycle;

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.d.ts

@@ -0,0 +1,17 @@
+import { LifeCycle, TaskResult } from '../../tasks-runner/life-cycle';
+import { Task } from '../../config/task-graph';
+export declare class StoreRunInformationLifeCycle implements LifeCycle {
+    private readonly command;
+    private readonly storeFile;
+    private readonly now;
+    private startTime;
+    private timings;
+    private taskResults;
+    constructor(command?: string, storeFile?: typeof storeFileFunction, now?: () => string);
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): void;
+    startCommand(): void;
+    endCommand(): any;
+}
+declare function storeFileFunction(runDetails: any): void;
+export {};

package/src/tasks-runner/life-cycles/store-run-information-life-cycle.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StoreRunInformationLifeCycle = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const cache_directory_1 = require("../../utils/cache-directory");
+class StoreRunInformationLifeCycle {
+    constructor(command = parseCommand(), storeFile = storeFileFunction, now = () => new Date().toISOString()) {
+        this.command = command;
+        this.storeFile = storeFile;
+        this.now = now;
+        this.timings = {};
+        this.taskResults = [];
+    }
+    startTasks(tasks) {
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                start: this.now(),
+                end: undefined,
+            };
+        }
+    }
+    endTasks(taskResults) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].start = new Date(tr.task.startTime).toISOString();
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].end = new Date(tr.task.endTime).toISOString();
+            }
+            else {
+                this.timings[tr.task.id].end = this.now();
+            }
+        }
+        this.taskResults.push(...taskResults);
+    }
+    startCommand() {
+        this.startTime = this.now();
+    }
+    endCommand() {
+        try {
+            const endTime = this.now();
+            const runDetails = {
+                run: {
+                    command: this.command,
+                    startTime: this.startTime,
+                    endTime: endTime,
+                    inner: false,
+                },
+                tasks: this.taskResults.map((tr) => {
+                    const cacheStatus = tr.status === 'remote-cache'
+                        ? 'remote-cache-hit'
+                        : tr.status === 'local-cache' ||
+                            tr.status === 'local-cache-kept-existing'
+                            ? 'local-cache-hit'
+                            : 'cache-miss';
+                    return {
+                        taskId: tr.task.id,
+                        target: tr.task.target.target,
+                        projectName: tr.task.target.project,
+                        hash: tr.task.hash,
+                        startTime: this.timings[tr.task.id].start,
+                        endTime: this.timings[tr.task.id].end,
+                        params: '',
+                        cacheStatus,
+                        status: tr.code,
+                    };
+                }),
+            };
+            this.storeFile(runDetails);
+        }
+        catch (e) {
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.error(e);
+            }
+        }
+    }
+}
+exports.StoreRunInformationLifeCycle = StoreRunInformationLifeCycle;
+function parseCommand() {
+    const cmdBase = (0, path_1.parse)(process.argv[1]).name;
+    const args = `${process.argv.slice(2).join(' ')}`;
+    return `${cmdBase} ${args}`;
+}
+function storeFileFunction(runDetails) {
+    (0, fs_1.writeFileSync)((0, path_1.join)(cache_directory_1.cacheDir, 'run.json'), JSON.stringify(runDetails, null, 2));
+}

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.d.ts

@@ -0,0 +1,9 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class LegacyTaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private taskRuns;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+}

package/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyTaskHistoryLifeCycle = void 0;
+const serialize_target_1 = require("../../utils/serialize-target");
+const output_1 = require("../../utils/output");
+const legacy_task_history_1 = require("../../utils/legacy-task-history");
+class LegacyTaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.taskRuns = [];
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        const taskRuns = taskResults.map((taskResult) => ({
+            project: taskResult.task.target.project,
+            target: taskResult.task.target.target,
+            configuration: taskResult.task.target.configuration,
+            hash: taskResult.task.hash,
+            code: taskResult.code.toString(),
+            status: taskResult.status,
+            start: (taskResult.task.startTime ?? this.startTimings[taskResult.task.id]).toString(),
+            end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
+        }));
+        this.taskRuns.push(...taskRuns);
+    }
+    async endCommand() {
+        await (0, legacy_task_history_1.writeTaskRunsToHistory)(this.taskRuns);
+        const history = await (0, legacy_task_history_1.getHistoryForHashes)(this.taskRuns.map((t) => t.hash));
+        const flakyTasks = [];
+        // check if any hash has different exit codes => flaky
+        for (let hash in history) {
+            if (history[hash].length > 1 &&
+                history[hash].some((run) => run.code !== history[hash][0].code)) {
+                flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+            }
+        }
+        if (flakyTasks.length > 0) {
+            output_1.output.warn({
+                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                bodyLines: [
+                    ,
+                    ...flakyTasks.map((t) => `  ${t}`),
+                    '',
+                    `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                ],
+            });
+        }
+    }
+}
+exports.LegacyTaskHistoryLifeCycle = LegacyTaskHistoryLifeCycle;

package/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -0,0 +1,10 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private taskRuns;
+    private taskHistory;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+}

package/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistoryLifeCycle = void 0;
+const serialize_target_1 = require("../../utils/serialize-target");
+const output_1 = require("../../utils/output");
+const task_history_1 = require("../../utils/task-history");
+class TaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.taskRuns = new Map();
+        this.taskHistory = (0, task_history_1.getTaskHistory)();
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        taskResults
+            .map((taskResult) => ({
+            hash: taskResult.task.hash,
+            target: taskResult.task.target,
+            code: taskResult.code,
+            status: taskResult.status,
+            start: taskResult.task.startTime ?? this.startTimings[taskResult.task.id],
+            end: taskResult.task.endTime ?? Date.now(),
+        }))
+            .forEach((taskRun) => {
+            this.taskRuns.set(taskRun.hash, taskRun);
+        });
+    }
+    async endCommand() {
+        const entries = Array.from(this.taskRuns);
+        if (!this.taskHistory) {
+            return;
+        }
+        await this.taskHistory.recordTaskRuns(entries.map(([_, v]) => v));
+        const flakyTasks = await this.taskHistory.getFlakyTasks(entries.map(([hash]) => hash));
+        if (flakyTasks.length > 0) {
+            output_1.output.warn({
+                title: `Nx detected ${flakyTasks.length === 1 ? 'a flaky task' : ' flaky tasks'}`,
+                bodyLines: [
+                    ,
+                    ...flakyTasks.map((hash) => {
+                        const taskRun = this.taskRuns.get(hash);
+                        return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
+                    }),
+                    '',
+                    `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                ],
+            });
+        }
+    }
+}
+exports.TaskHistoryLifeCycle = TaskHistoryLifeCycle;

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.d.ts

@@ -0,0 +1,14 @@
+import { LifeCycle, TaskMetadata, TaskResult } from '../life-cycle';
+import { Task } from '../../config/task-graph';
+export declare class TaskProfilingLifeCycle implements LifeCycle {
+    private timings;
+    private profile;
+    private readonly profileFile;
+    private registeredGroups;
+    constructor(_profileFile: string);
+    startTasks(tasks: Task[], { groupId }: TaskMetadata): void;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    endCommand(): void;
+    private recordTaskCompletions;
+    private registerGroup;
+}

package/src/tasks-runner/life-cycles/task-profiling-life-cycle.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskProfilingLifeCycle = void 0;
+const path_1 = require("path");
+const fileutils_1 = require("../../utils/fileutils");
+class TaskProfilingLifeCycle {
+    constructor(_profileFile) {
+        this.timings = {};
+        this.profile = [];
+        this.registeredGroups = new Set();
+        this.profileFile = (0, path_1.join)(process.cwd(), _profileFile);
+    }
+    startTasks(tasks, { groupId }) {
+        if (this.profileFile && !this.registeredGroups.has(groupId)) {
+            this.registerGroup(groupId);
+        }
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                perfStart: Date.now(),
+            };
+        }
+    }
+    endTasks(taskResults, metadata) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].perfStart = tr.task.startTime;
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].perfEnd = tr.task.endTime;
+            }
+            else {
+                this.timings[tr.task.id].perfEnd = Date.now();
+            }
+        }
+        this.recordTaskCompletions(taskResults, metadata);
+    }
+    endCommand() {
+        (0, fileutils_1.writeJsonFile)(this.profileFile, this.profile);
+        console.log(`Performance Profile: ${this.profileFile}`);
+    }
+    recordTaskCompletions(tasks, { groupId }) {
+        for (const { task, status } of tasks) {
+            const { perfStart, perfEnd } = this.timings[task.id];
+            this.profile.push({
+                name: task.id,
+                cat: Object.values(task.target).join(','),
+                ph: 'X',
+                ts: perfStart * 1000,
+                dur: (perfEnd - perfStart) * 1000,
+                pid: process.pid,
+                tid: groupId,
+                args: {
+                    target: task.target,
+                    status,
+                },
+            });
+        }
+    }
+    registerGroup(groupId) {
+        this.profile.push({
+            name: 'thread_name',
+            ph: 'M',
+            pid: process.pid,
+            tid: groupId,
+            ts: 0,
+            args: {
+                name: 'Group #' + (groupId + 1),
+            },
+        });
+        this.registeredGroups.add(groupId);
+    }
+}
+exports.TaskProfilingLifeCycle = TaskProfilingLifeCycle;

package/src/tasks-runner/life-cycles/task-results-life-cycle.d.ts

@@ -0,0 +1,6 @@
+import type { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskResultsLifeCycle implements LifeCycle {
+    private taskResults;
+    endTasks(taskResults: TaskResult[]): void;
+    getTaskResults(): Record<string, TaskResult>;
+}

package/src/tasks-runner/life-cycles/task-results-life-cycle.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskResultsLifeCycle = void 0;
+class TaskResultsLifeCycle {
+    constructor() {
+        this.taskResults = {};
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            this.taskResults[t.task.id] = t;
+        }
+    }
+    getTaskResults() {
+        return this.taskResults;
+    }
+}
+exports.TaskResultsLifeCycle = TaskResultsLifeCycle;

package/src/tasks-runner/life-cycles/task-timings-life-cycle.d.ts

@@ -0,0 +1,8 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class TaskTimingsLifeCycle implements LifeCycle {
+    private timings;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): void;
+    endCommand(): void;
+}

package/src/tasks-runner/life-cycles/task-timings-life-cycle.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskTimingsLifeCycle = void 0;
+class TaskTimingsLifeCycle {
+    constructor() {
+        this.timings = {};
+    }
+    startTasks(tasks) {
+        for (let t of tasks) {
+            this.timings[t.id] = {
+                start: new Date().getTime(),
+                end: undefined,
+            };
+        }
+    }
+    endTasks(taskResults) {
+        for (let tr of taskResults) {
+            if (tr.task.startTime) {
+                this.timings[tr.task.id].start = tr.task.startTime;
+            }
+            if (tr.task.endTime) {
+                this.timings[tr.task.id].end = tr.task.endTime;
+            }
+            else {
+                this.timings[tr.task.id].end = new Date().getTime();
+            }
+        }
+    }
+    endCommand() {
+        console.log('Task Execution Timings:');
+        const timings = {};
+        Object.keys(this.timings).forEach((p) => {
+            const t = this.timings[p];
+            timings[p] = t.end ? t.end - t.start : null;
+        });
+        console.log(JSON.stringify(timings, null, 2));
+    }
+}
+exports.TaskTimingsLifeCycle = TaskTimingsLifeCycle;

package/src/tasks-runner/life-cycles/view-logs-utils.d.ts

@@ -0,0 +1 @@
+export declare function viewLogsFooterRows(failedTasks: number): string[];

package/src/tasks-runner/life-cycles/view-logs-utils.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewLogsFooterRows = viewLogsFooterRows;
+const nx_json_1 = require("../../config/nx-json");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const output_1 = require("../../utils/output");
+const VIEW_LOGS_MESSAGE = `Hint: Try "nx view-logs" to get structured, searchable errors logs in your browser.`;
+function viewLogsFooterRows(failedTasks) {
+    if (failedTasks >= 2 && !(0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())) {
+        return [``, output_1.output.dim(` ${VIEW_LOGS_MESSAGE}`)];
+    }
+    else {
+        return [];
+    }
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Node IPC is specific to Node, but when spawning child processes in Rust, it won't have IPC.
+ *
+ * Thus, this is a wrapper which is spawned by Rust, which will create a Node IPC channel and pipe it to a ZeroMQ Channel
+ *
+ * Main Nx Process
+ *   * Calls Rust Fork Function
+ *     * `node fork.js`
+ *     * Create a Rust - Node.js Agnostic Channel aka Pseudo IPC Channel
+ *     * This returns RustChildProcess
+ *         * RustChildProcess.onMessage(msg => ());
+ *         * pseudo_ipc_channel.on_message() => tx.send(msg);
+ *   * Node.js Fork Wrapper (fork.js)
+ *     * fork(run-command.js) with `inherit` and `ipc`
+ *         * This will create a Node IPC Channel
+ *     * channel = getPseudoIpcChannel(process.env.NX_IPC_CHANNEL_ID)
+ *     * forkChildProcess.on('message', writeToPseudoIpcChannel)
+ */
+import { Serializable } from 'child_process';
+export interface PseudoIPCMessage {
+    type: 'TO_CHILDREN_FROM_PARENT' | 'TO_PARENT_FROM_CHILDREN' | 'CHILD_READY';
+    id: string | undefined;
+    message: Serializable;
+}
+export declare class PseudoIPCServer {
+    private path;
+    private sockets;
+    private server;
+    private childMessages;
+    constructor(path: string);
+    init(): Promise<void>;
+    private childReadyMap;
+    waitForChildReady(childId: string): Promise<void>;
+    private registerChildMessages;
+    sendMessageToChildren(message: Serializable): void;
+    sendMessageToChild(id: string, message: Serializable): void;
+    onMessageFromChildren(onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): void;
+    close(): void;
+}
+export declare class PseudoIPCClient {
+    private path;
+    private socket;
+    constructor(path: string);
+    sendMessageToParent(message: Serializable): void;
+    notifyChildIsReady(id: string): void;
+    onMessageFromParent(forkId: string, onMessage: (message: Serializable) => void, onClose?: () => void, onError?: (err: Error) => void): this;
+    close(): void;
+}