nx 21.0.0-beta.2 → 21.0.0-beta.4

package/src/executors/run-script/run-script.impl.js

@@ -40,6 +40,7 @@ function nodeProcess(command, cwd, env) {
 }
 async function ptyProcess(command, cwd, env) {
     const terminal = (0, pseudo_terminal_1.createPseudoTerminal)();
+    await terminal.init();
     return new Promise((res, rej) => {
         const cp = terminal.runCommand(command, { cwd, jsEnv: env });
         cp.onExit((code) => {

package/src/native/index.js

@@ -1,5 +1,5 @@
 const { join, basename } = require('path');
-const { copyFileSync, existsSync, mkdirSync } = require('fs');
+const { copyFileSync, existsSync, mkdirSync, renameSync } = require('fs');
 const Module = require('module');
 const { nxVersion } = require('../utils/versions');
 const { getNativeFileCacheLocation } = require('./native-file-cache-location');
@@ -71,14 +71,28 @@ Module._load = function (request, parent, isMain) {
 
     // we copy the file to a workspace-scoped tmp directory and prefix with nxVersion to avoid stale files being loaded
     const nativeFileCacheLocation = getNativeFileCacheLocation();
+    // This is a path to copy to, not the one that gets loaded
+    const tmpTmpFile = join(
+      nativeFileCacheLocation,
+      nxVersion + '-' + Math.random() + fileName
+    );
+    // This is the path that will get loaded
     const tmpFile = join(nativeFileCacheLocation, nxVersion + '-' + fileName);
+
+    // If the file to be loaded already exists, just load it
     if (existsSync(tmpFile)) {
       return originalLoad.apply(this, [tmpFile, parent, isMain]);
     }
     if (!existsSync(nativeFileCacheLocation)) {
       mkdirSync(nativeFileCacheLocation, { recursive: true });
     }
-    copyFileSync(nativeLocation, tmpFile);
+    // First copy to a unique location for each process
+    copyFileSync(nativeLocation, tmpTmpFile);
+
+    // Then rename to the final location
+    renameSync(tmpTmpFile, tmpFile);
+
+    // Load from the final location
     return originalLoad.apply(this, [tmpFile, parent, isMain]);
   } else {
     // call the original _load function for everything else

package/src/plugins/package-json/create-nodes.d.ts

@@ -1,5 +1,5 @@
 import { NxJsonConfiguration } from '../../config/nx-json';
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { ProjectConfiguration } from '../../config/workspace-json-project-json';
 import { PackageJson } from '../../utils/package-json';
 import { CreateNodesV2 } from '../../project-graph/plugins';
 import { PackageJsonConfigurationCache } from '../../../plugins/package-json';

package/src/tasks-runner/forked-process-task-runner.d.ts

@@ -11,10 +11,12 @@ export declare class ForkedProcessTaskRunner {
     cliPath: string;
     private readonly verbose;
     private processes;
+    private finishedProcesses;
     private pseudoTerminals;
     constructor(options: DefaultTasksRunnerOptions, tuiEnabled: boolean);
     init(): Promise<void>;
     forkProcessForBatch({ executorName, taskGraph: batchTaskGraph }: Batch, projectGraph: ProjectGraph, fullTaskGraph: TaskGraph, env: NodeJS.ProcessEnv): Promise<BatchProcess>;
+    cleanUpBatchProcesses(): void;
     forkProcessLegacy(task: Task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }: {
         temporaryOutputPath: string;
         streamOutput: boolean;

package/src/tasks-runner/forked-process-task-runner.js

@@ -22,6 +22,7 @@ class ForkedProcessTaskRunner {
         this.cliPath = (0, utils_1.getCliPath)();
         this.verbose = process.env.NX_VERBOSE_LOGGING === 'true';
         this.processes = new Set();
+        this.finishedProcesses = new Set();
         this.pseudoTerminals = new Set();
     }
     async init() {
@@ -56,6 +57,14 @@ class ForkedProcessTaskRunner {
         });
         return cp;
     }
+    cleanUpBatchProcesses() {
+        if (this.finishedProcesses.size > 0) {
+            this.finishedProcesses.forEach((p) => {
+                p.kill();
+            });
+            this.finishedProcesses.clear();
+        }
+    }
     async forkProcessLegacy(task, { temporaryOutputPath, streamOutput, pipeOutput, taskGraph, env, }) {
         return pipeOutput
             ? this.forkProcessWithPrefixAndNotTTY(task, {
@@ -221,41 +230,41 @@ class ForkedProcessTaskRunner {
         (0, fs_1.writeFileSync)(outputPath, content);
     }
     setupProcessEventListeners() {
-        // When the nx process gets a message, it will be sent into the task's process
-        process.on('message', (message) => {
+        const messageHandler = (message) => {
             this.pseudoTerminals.forEach((p) => {
                 p.sendMessageToChildren(message);
             });
             this.processes.forEach((p) => {
-                if ('send' in p) {
+                if ('connected' in p && p.connected && 'send' in p) {
                     p.send(message);
                 }
             });
-        });
-        // Terminate any task processes on exit
-        process.on('exit', () => {
+        };
+        // When the nx process gets a message, it will be sent into the task's process
+        process.on('message', messageHandler);
+        const cleanUp = (signal) => {
             this.processes.forEach((p) => {
-                p.kill();
+                p.kill(signal);
             });
+            process.off('message', messageHandler);
+            this.cleanUpBatchProcesses();
+        };
+        // Terminate any task processes on exit
+        process.once('exit', () => {
+            cleanUp();
         });
-        process.on('SIGINT', () => {
-            this.processes.forEach((p) => {
-                p.kill('SIGTERM');
-            });
+        process.once('SIGINT', () => {
+            cleanUp('SIGTERM');
             // we exit here because we don't need to write anything to cache.
             process.exit((0, exit_codes_1.signalToCode)('SIGINT'));
         });
-        process.on('SIGTERM', () => {
-            this.processes.forEach((p) => {
-                p.kill('SIGTERM');
-            });
+        process.once('SIGTERM', () => {
+            cleanUp('SIGTERM');
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
         });
-        process.on('SIGHUP', () => {
-            this.processes.forEach((p) => {
-                p.kill('SIGTERM');
-            });
+        process.once('SIGHUP', () => {
+            cleanUp('SIGTERM');
             // no exit here because we expect child processes to terminate which
             // will store results to the cache and will terminate this process
         });

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

@@ -75,12 +75,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');
@@ -201,6 +205,7 @@ class TaskOrchestrator {
             results.push(...batchResults);
         }
         await this.postRunSteps(tasks, results, doNotSkipCache, { groupId });
+        this.forkedProcessTaskRunner.cleanUpBatchProcesses();
         const tasksCompleted = taskEntries.filter(([taskId]) => this.completedTasks[taskId]);
         // Batch is still not done, run it again
         if (tasksCompleted.length !== taskEntries.length) {