nx 18.1.0-canary.20240315-3b8cbae → 18.1.1

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

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PseudoTtyProcessWithSend = exports.PseudoTtyProcess = exports.PseudoTerminal = exports.getPseudoTerminal = void 0;
+const native_1 = require("../native");
+const pseudo_ipc_1 = require("./pseudo-ipc");
+const socket_utils_1 = require("../daemon/socket-utils");
+let pseudoTerminal;
+function getPseudoTerminal() {
+    pseudoTerminal ??= new PseudoTerminal(new native_1.RustPseudoTerminal());
+    return pseudoTerminal;
+}
+exports.getPseudoTerminal = getPseudoTerminal;
+class PseudoTerminal {
+    constructor(rustPseudoTerminal) {
+        this.rustPseudoTerminal = rustPseudoTerminal;
+        this.pseudoIPCPath = (0, socket_utils_1.FORKED_PROCESS_OS_SOCKET_PATH)(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, jsEnv, quiet, } = {}) {
+        return new PseudoTtyProcess(this.rustPseudoTerminal.runCommand(command, cwd, jsEnv, quiet));
+    }
+    async fork(id, script, { cwd, 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, 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;
+    }
+}

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

@@ -54,7 +54,6 @@ class TaskOrchestrator {
         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.forkedProcessTaskRunner.destroy();
         this.cache.removeOldCacheRecords();
         return this.completedTasks;
     }

package/src/utils/ignore.js

@@ -27,7 +27,7 @@ function getIgnoredGlobs(root = workspace_root_1.workspaceRoot, prependRoot = tr
 }
 exports.getIgnoredGlobs = getIgnoredGlobs;
 function getAlwaysIgnore(root) {
-    const paths = ['node_modules', '**/node_modules', '.git'];
+    const paths = ['node_modules', '**/node_modules', '.git', '.nx', '.vscode'];
     return root ? paths.map((x) => (0, path_1.joinPathFragments)(root, x)) : paths;
 }
 exports.getAlwaysIgnore = getAlwaysIgnore;

package/src/utils/nx-plugin.d.ts

@@ -10,6 +10,10 @@ import { RawProjectGraphDependency } from '../project-graph/project-graph-builde
 export interface CreateNodesContext {
     readonly nxJsonConfiguration: NxJsonConfiguration;
     readonly workspaceRoot: string;
+    /**
+     * The subset of configuration files which match the createNodes pattern
+     */
+    readonly configFiles: string[];
 }
 /**
  * A function which parses a configuration file into a set of nodes.
@@ -30,7 +34,7 @@ export interface CreateNodesResult {
  * A pair of file patterns and {@link CreateNodesFunction}
  */
 export type CreateNodes<T = unknown> = readonly [
-    projectFilePattern: string,
+    configFilePattern: string,
     createNodesFunction: CreateNodesFunction<T>
 ];
 /**