@ohos-ports/nx 19.8.4-beta.0

package/src/tasks-runner/pseudo-ipc.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * 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)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoIPCClient = exports.PseudoIPCServer = void 0;
+const net_1 = require("net");
+const consume_messages_from_socket_1 = require("../utils/consume-messages-from-socket");
+class PseudoIPCServer {
+    constructor(path) {
+        this.path = path;
+        this.sockets = new Set();
+        this.childMessages = [];
+        this.childReadyMap = new Map();
+    }
+    init() {
+        return new Promise((res) => {
+            this.server = new net_1.Server((socket) => {
+                this.sockets.add(socket);
+                this.registerChildMessages(socket);
+                socket.on('close', () => {
+                    this.sockets.delete(socket);
+                });
+            });
+            this.server.listen(this.path, () => {
+                res();
+            });
+        });
+    }
+    async waitForChildReady(childId) {
+        return new Promise((res) => {
+            this.childReadyMap.set(childId, res);
+        });
+    }
+    registerChildMessages(socket) {
+        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
+            const { type, message } = JSON.parse(rawMessage);
+            if (type === 'TO_PARENT_FROM_CHILDREN') {
+                for (const childMessage of this.childMessages) {
+                    childMessage.onMessage(message);
+                }
+            }
+            else if (type === 'CHILD_READY') {
+                const childId = message;
+                if (this.childReadyMap.has(childId)) {
+                    this.childReadyMap.get(childId)();
+                }
+            }
+        }));
+        socket.on('close', () => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onClose?.();
+            }
+        });
+        socket.on('error', (err) => {
+            for (const childMessage of this.childMessages) {
+                childMessage.onError?.(err);
+            }
+        });
+    }
+    sendMessageToChildren(message) {
+        this.sockets.forEach((socket) => {
+            socket.write(JSON.stringify({ type: 'TO_CHILDREN_FROM_PARENT', message }));
+            // send EOT to indicate that the message has been fully written
+            socket.write(String.fromCodePoint(4));
+        });
+    }
+    sendMessageToChild(id, message) {
+        this.sockets.forEach((socket) => {
+            socket.write(JSON.stringify({ type: 'TO_CHILDREN_FROM_PARENT', id, message }));
+            socket.write(String.fromCodePoint(4));
+        });
+    }
+    onMessageFromChildren(onMessage, onClose = () => { }, onError = (err) => { }) {
+        this.childMessages.push({
+            onMessage,
+            onClose,
+            onError,
+        });
+    }
+    close() {
+        this.server?.close();
+        this.sockets.forEach((s) => s.destroy());
+    }
+}
+exports.PseudoIPCServer = PseudoIPCServer;
+class PseudoIPCClient {
+    constructor(path) {
+        this.path = path;
+        this.socket = (0, net_1.connect)(this.path);
+    }
+    sendMessageToParent(message) {
+        this.socket.write(JSON.stringify({ type: 'TO_PARENT_FROM_CHILDREN', message }));
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(String.fromCodePoint(4));
+    }
+    notifyChildIsReady(id) {
+        this.socket.write(JSON.stringify({
+            type: 'CHILD_READY',
+            message: id,
+        }));
+        // send EOT to indicate that the message has been fully written
+        this.socket.write(String.fromCodePoint(4));
+    }
+    onMessageFromParent(forkId, onMessage, onClose = () => { }, onError = (err) => { }) {
+        this.socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(async (rawMessage) => {
+            const { id, type, message } = JSON.parse(rawMessage);
+            if (type === 'TO_CHILDREN_FROM_PARENT') {
+                if (id && id === forkId) {
+                    onMessage(message);
+                }
+                else if (id === undefined) {
+                    onMessage(message);
+                }
+            }
+        }));
+        this.socket.on('close', onClose);
+        this.socket.on('error', onError);
+        return this;
+    }
+    close() {
+        this.socket?.destroy();
+    }
+}
+exports.PseudoIPCClient = PseudoIPCClient;

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

@@ -0,0 +1,45 @@
+import { ChildProcess, RustPseudoTerminal } from '../native';
+import { PseudoIPCServer } from './pseudo-ipc';
+import { Serializable } from 'child_process';
+export declare function getPseudoTerminal(skipSupportCheck?: boolean): PseudoTerminal;
+export declare class PseudoTerminal {
+    private rustPseudoTerminal;
+    private pseudoIPCPath;
+    private pseudoIPC;
+    private initialized;
+    static isSupported(): boolean;
+    constructor(rustPseudoTerminal: RustPseudoTerminal);
+    init(): Promise<void>;
+    runCommand(command: string, { cwd, execArgv, jsEnv, quiet, tty, }?: {
+        cwd?: string;
+        execArgv?: string[];
+        jsEnv?: Record<string, string>;
+        quiet?: boolean;
+        tty?: boolean;
+    }): PseudoTtyProcess;
+    fork(id: string, script: string, { cwd, execArgv, jsEnv, quiet, }: {
+        cwd?: string;
+        execArgv?: string[];
+        jsEnv?: Record<string, string>;
+        quiet?: boolean;
+    }): Promise<PseudoTtyProcessWithSend>;
+    sendMessageToChildren(message: Serializable): void;
+    onMessageFromChildren(callback: (message: Serializable) => void): void;
+    private setupProcessListeners;
+    private shutdownPseudoIPC;
+}
+export declare class PseudoTtyProcess {
+    private childProcess;
+    isAlive: boolean;
+    exitCallbacks: any[];
+    constructor(childProcess: ChildProcess);
+    onExit(callback: (code: number) => void): void;
+    onOutput(callback: (message: string) => void): void;
+    kill(): void;
+}
+export declare class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    private id;
+    private pseudoIpc;
+    constructor(_childProcess: ChildProcess, id: string, pseudoIpc: PseudoIPCServer);
+    send(message: Serializable): void;
+}

package/src/tasks-runner/pseudo-terminal.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerminal = void 0;
+exports.getPseudoTerminal = getPseudoTerminal;
+const native_1 = require("../native");
+const pseudo_ipc_1 = require("./pseudo-ipc");
+const socket_utils_1 = require("../daemon/socket-utils");
+const os = require("os");
+let pseudoTerminal;
+function getPseudoTerminal(skipSupportCheck = false) {
+    if (!skipSupportCheck && !PseudoTerminal.isSupported()) {
+        throw new Error('Pseudo terminal is not supported on this platform.');
+    }
+    pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
+    return pseudoTerminal;
+}
+class PseudoTerminal {
+    static isSupported() {
+        return process.stdout.isTTY && supportedPtyPlatform();
+    }
+    constructor(rustPseudoTerminal) {
+        this.rustPseudoTerminal = rustPseudoTerminal;
+        this.pseudoIPCPath = (0, socket_utils_1.getForkedProcessOsSocketPath)(process.pid.toString());
+        this.pseudoIPC = new pseudo_ipc_1.PseudoIPCServer(this.pseudoIPCPath);
+        this.initialized = false;
+        this.setupProcessListeners();
+    }
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        await this.pseudoIPC.init();
+        this.initialized = true;
+    }
+    runCommand(command, { cwd, execArgv, jsEnv, quiet, tty, } = {}) {
+        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, execArgv, quiet, tty));
+    }
+    async fork(id, script, { cwd, execArgv, jsEnv, quiet, }) {
+        if (!this.initialized) {
+            throw new Error('Call init() before forking processes');
+        }
+        const cp = new PseudoTtyProcessWithSend(this.rustPseudoTerminal.fork(id, script, this.pseudoIPCPath, cwd, jsEnv, execArgv, quiet), id, this.pseudoIPC);
+        await this.pseudoIPC.waitForChildReady(id);
+        return cp;
+    }
+    sendMessageToChildren(message) {
+        this.pseudoIPC.sendMessageToChildren(message);
+    }
+    onMessageFromChildren(callback) {
+        this.pseudoIPC.onMessageFromChildren(callback);
+    }
+    setupProcessListeners() {
+        const shutdown = () => {
+            this.shutdownPseudoIPC();
+        };
+        process.on('SIGINT', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('SIGTERM', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('SIGHUP', () => {
+            this.shutdownPseudoIPC();
+        });
+        process.on('exit', () => {
+            this.shutdownPseudoIPC();
+        });
+    }
+    shutdownPseudoIPC() {
+        if (this.initialized) {
+            this.pseudoIPC.close();
+        }
+    }
+}
+exports.PseudoTerminal = PseudoTerminal;
+class PseudoTtyProcess {
+    constructor(childProcess) {
+        this.childProcess = childProcess;
+        this.isAlive = true;
+        this.exitCallbacks = [];
+        childProcess.onExit((message) => {
+            this.isAlive = false;
+            const exitCode = messageToCode(message);
+            this.exitCallbacks.forEach((cb) => cb(exitCode));
+        });
+    }
+    onExit(callback) {
+        this.exitCallbacks.push(callback);
+    }
+    onOutput(callback) {
+        this.childProcess.onOutput(callback);
+    }
+    kill() {
+        try {
+            this.childProcess.kill();
+        }
+        catch {
+            // when the child process completes before we explicitly call kill, this will throw
+            // do nothing
+        }
+        finally {
+            if (this.isAlive == true) {
+                this.isAlive = false;
+            }
+        }
+    }
+}
+exports.PseudoTtyProcess = PseudoTtyProcess;
+class PseudoTtyProcessWithSend extends PseudoTtyProcess {
+    constructor(_childProcess, id, pseudoIpc) {
+        super(_childProcess);
+        this.id = id;
+        this.pseudoIpc = pseudoIpc;
+    }
+    send(message) {
+        this.pseudoIpc.sendMessageToChild(this.id, message);
+    }
+}
+exports.PseudoTtyProcessWithSend = PseudoTtyProcessWithSend;
+function messageToCode(message) {
+    if (message.startsWith('Terminated by ')) {
+        switch (message.replace('Terminated by ', '').trim()) {
+            case 'Termination':
+                return 143;
+            case 'Interrupt':
+                return 130;
+            default:
+                return 128;
+        }
+    }
+    else if (message.startsWith('Exited with code ')) {
+        return parseInt(message.replace('Exited with code ', '').trim());
+    }
+    else if (message === 'Success') {
+        return 0;
+    }
+    else {
+        return 1;
+    }
+}
+function supportedPtyPlatform() {
+    if (native_1.IS_WASM) {
+        return false;
+    }
+    if (process.platform !== 'win32') {
+        return true;
+    }
+    // TODO: Re-enable Windows support when it's stable
+    // Currently, there's an issue with control chars.
+    // See: https://github.com/nrwl/nx/issues/22358
+    if (process.env.NX_WINDOWS_PTY_SUPPORT !== 'true') {
+        return false;
+    }
+    let windowsVersion = os.release().split('.');
+    let windowsBuild = windowsVersion[2];
+    if (!windowsBuild) {
+        return false;
+    }
+    // Mininum supported Windows version:
+    // https://en.wikipedia.org/wiki/Windows_10,_version_1809
+    // https://learn.microsoft.com/en-us/windows/console/createpseudoconsole#requirements
+    if (+windowsBuild < 17763) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}

package/src/tasks-runner/remove-old-cache-records.d.ts

@@ -0,0 +1 @@
+export {};

package/src/tasks-runner/remove-old-cache-records.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const path_1 = require("path");
+const WEEK_IN_MS = 1000 * 60 * 60 * 24 * 7;
+const folder = process.argv[2];
+removeOld(terminalOutputs());
+removeOld(cachedFiles());
+function terminalOutputs() {
+    try {
+        return (0, fs_1.readdirSync)((0, path_1.join)(folder, 'terminalOutputs')).map((f) => (0, path_1.join)(folder, 'terminalOutputs', f));
+    }
+    catch (e) {
+        return [];
+    }
+}
+function cachedFiles() {
+    try {
+        return (0, fs_1.readdirSync)(folder)
+            .filter((f) => !f.endsWith('terminalOutputs'))
+            .map((f) => (0, path_1.join)(folder, f));
+    }
+    catch (e) {
+        return [];
+    }
+}
+function removeOld(records) {
+    try {
+        const time = mostRecentMTime(records);
+        records.forEach((r) => {
+            try {
+                const s = (0, fs_1.statSync)(r);
+                if (time - s.mtimeMs > WEEK_IN_MS) {
+                    if (s.isDirectory()) {
+                        try {
+                            (0, fs_1.rmSync)(`${r}.commit`, { recursive: true, force: true });
+                        }
+                        catch (e) { }
+                    }
+                    (0, fs_1.rmSync)(r, { recursive: true, force: true });
+                }
+            }
+            catch (e) { }
+        });
+    }
+    catch (e) { }
+}
+function mostRecentMTime(records) {
+    let mostRecentTime = 0;
+    records.forEach((r) => {
+        try {
+            const s = (0, fs_1.statSync)(r);
+            if (s.mtimeMs > mostRecentTime) {
+                mostRecentTime = s.mtimeMs;
+            }
+        }
+        catch (e) { }
+    });
+    return mostRecentTime;
+}

package/src/tasks-runner/run-command.d.ts

@@ -0,0 +1,38 @@
+import { NxJsonConfiguration } from '../config/nx-json';
+import { ProjectGraph, ProjectGraphProjectNode } from '../config/project-graph';
+import { Task, TaskGraph } from '../config/task-graph';
+import { TargetDependencyConfig } from '../config/workspace-json-project-json';
+import { NxArgs } from '../utils/command-line-utils';
+import { LifeCycle, TaskResult } from './life-cycle';
+import { TasksRunner } from './tasks-runner';
+export declare function runCommand(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+    nxJson: NxJsonConfiguration;
+}, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<NodeJS.Process['exitCode']>;
+export declare function runCommandForTasks(projectsToRun: ProjectGraphProjectNode[], currentProjectGraph: ProjectGraph, { nxJson }: {
+    nxJson: NxJsonConfiguration;
+}, nxArgs: NxArgs, overrides: any, initiatingProject: string | null, extraTargetDependencies: Record<string, (TargetDependencyConfig | string)[]>, extraOptions: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<{
+    [id: string]: TaskResult;
+}>;
+export declare function invokeTasksRunner({ tasks, projectGraph, taskGraph, lifeCycle, nxJson, nxArgs, loadDotEnvFiles, initiatingProject, }: {
+    tasks: Task[];
+    projectGraph: ProjectGraph;
+    taskGraph: TaskGraph;
+    lifeCycle: LifeCycle;
+    nxJson: NxJsonConfiguration;
+    nxArgs: NxArgs;
+    loadDotEnvFiles: boolean;
+    initiatingProject: string | null;
+}): Promise<{
+    [id: string]: TaskResult;
+}>;
+export declare function getRunner(nxArgs: NxArgs, nxJson: NxJsonConfiguration): {
+    tasksRunner: TasksRunner;
+    runnerOptions: any;
+};
+export declare function getRunnerOptions(runner: string, nxJson: NxJsonConfiguration<string[] | '*'>, nxArgs: NxArgs, isCloudDefault: boolean): any;