nx 20.1.1 → 20.1.3

package/src/daemon/client/client.js

@@ -406,6 +406,9 @@ class DaemonClient {
         }
     }
     async startInBackground() {
+        if (global.NX_PLUGIN_WORKER) {
+            throw new Error('Fatal Error: Something unexpected has occurred. Plugin Workers should not start a new daemon process. Please report this issue.');
+        }
         (0, node_fs_1.mkdirSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE, { recursive: true });
         if (!(0, node_fs_1.existsSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE)) {
             (0, node_fs_1.writeFileSync)(tmp_dir_1.DAEMON_OUTPUT_LOG_FILE, '');

package/src/daemon/server/server.js

@@ -353,6 +353,15 @@ async function startServer() {
             server.listen((0, socket_utils_1.getFullOsSocketPath)(), async () => {
                 try {
                     logger_1.serverLogger.log(`Started listening on: ${(0, socket_utils_1.getFullOsSocketPath)()}`);
+                    setInterval(() => {
+                        if ((0, cache_1.getDaemonProcessIdSync)() !== process.pid) {
+                            return (0, shutdown_utils_1.handleServerProcessTermination)({
+                                server,
+                                reason: 'this process is no longer the current daemon (native)',
+                                sockets: exports.openSockets,
+                            });
+                        }
+                    }).unref();
                     // this triggers the storage of the lock file hash
                     daemonIsOutdated();
                     if (!(0, shutdown_utils_1.getWatcherInstance)()) {

package/src/daemon/tmp-dir.js

@@ -43,7 +43,7 @@ function isDaemonDisabled() {
 function socketDirName() {
     const hasher = (0, crypto_1.createHash)('sha256');
     hasher.update(workspace_root_1.workspaceRoot.toLowerCase());
-    const unique = hasher.digest('hex').substring(0, 10);
+    const unique = hasher.digest('hex').substring(0, 20);
     return (0, path_1.join)(tmp_1.tmpdir, unique);
 }
 /**

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -12,7 +12,15 @@ const pluginNames = new Map();
 const PLUGIN_TIMEOUT_HINT_TEXT = 'As a last resort, you can set NX_PLUGIN_NO_TIMEOUTS=true to bypass this timeout.';
 const MINUTES = 10;
 const MAX_MESSAGE_WAIT = process.env.NX_PLUGIN_NO_TIMEOUTS === 'true'
-    ? undefined
+    ? // Registering a timeout prevents the process from exiting
+        // if the call to a plugin happens to be the only thing
+        // keeping the process alive. As such, even if timeouts are disabled
+        // we need to register one. 2147483647 is the max timeout
+        // that Node.js allows, and is equivalent to 24.8 days....
+        // This does mean that the NX_PLUGIN_NO_TIMEOUTS env var
+        // would still timeout after 24.8 days, but that seems
+        // like a reasonable compromise.
+        2147483647
     : 1000 * 60 * MINUTES; // 10 minutes
 const nxPluginWorkerCache = (global['nxPluginWorkerCache'] ??= new Map());
 async function loadRemoteNxPlugin(plugin, root) {
@@ -35,11 +43,9 @@ async function loadRemoteNxPlugin(plugin, root) {
             payload: { plugin, root },
         });
         // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
-        const loadTimeout = MAX_MESSAGE_WAIT
-            ? setTimeout(() => {
-                rej(new Error(`Loading "${plugin}" timed out after ${MINUTES} minutes. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
-            }, MAX_MESSAGE_WAIT)
-            : undefined;
+        const loadTimeout = setTimeout(() => {
+            rej(new Error(`Loading "${typeof plugin === 'string' ? plugin : plugin.plugin}" timed out after ${MINUTES} minutes. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
+        }, MAX_MESSAGE_WAIT);
         socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(createWorkerHandler(worker, pendingPromises, (val) => {
             if (loadTimeout)
                 clearTimeout(loadTimeout);
@@ -169,11 +175,9 @@ function registerPendingPromise(tx, pending, callback, context) {
     const promise = new Promise((res, rej) => {
         rejector = rej;
         resolver = res;
-        timeout = MAX_MESSAGE_WAIT
-            ? setTimeout(() => {
-                rej(new Error(`${context.plugin} timed out after ${MINUTES} minutes during ${context.operation}. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
-            }, MAX_MESSAGE_WAIT)
-            : undefined;
+        timeout = setTimeout(() => {
+            rej(new Error(`${context.plugin} timed out after ${MINUTES} minutes during ${context.operation}. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
+        }, MAX_MESSAGE_WAIT);
         callback();
     }).finally(() => {
         pending.delete(tx);

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -10,9 +10,19 @@ if (process.env.NX_PERF_LOGGING === 'true') {
     require('../../../utils/perf-logging');
 }
 global.NX_GRAPH_CREATION = true;
+global.NX_PLUGIN_WORKER = true;
+let connected = false;
 let plugin;
 const socketPath = process.argv[2];
 const server = (0, net_1.createServer)((socket) => {
+    connected = true;
+    // This handles cases where the host process was killed
+    // after the worker connected but before the worker was
+    // instructed to load the plugin.
+    const loadTimeout = setTimeout(() => {
+        console.error(`Plugin Worker exited because no plugin was loaded within 10 seconds of starting up.`);
+        process.exit(1);
+    }, 10000).unref();
     socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {
         const message = JSON.parse(raw.toString());
         if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
@@ -20,6 +30,8 @@ const server = (0, net_1.createServer)((socket) => {
         }
         return (0, messaging_1.consumeMessage)(socket, message, {
             load: async ({ plugin: pluginConfiguration, root }) => {
+                if (loadTimeout)
+                    clearTimeout(loadTimeout);
                 process.chdir(root);
                 try {
                     const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
@@ -112,6 +124,8 @@ const server = (0, net_1.createServer)((socket) => {
     // since the worker is spawned per host process. As such,
     // we can safely close the worker when the host disconnects.
     socket.on('end', () => {
+        // Destroys the socket once it's fully closed.
+        socket.destroySoon();
         // Stops accepting new connections, but existing connections are
         // not closed immediately.
         server.close(() => {
@@ -121,11 +135,15 @@ const server = (0, net_1.createServer)((socket) => {
             catch (e) { }
             process.exit(0);
         });
-        // Destroys the socket once it's fully closed.
-        socket.destroySoon();
     });
 });
 server.listen(socketPath);
+setTimeout(() => {
+    if (!connected) {
+        console.error('The plugin worker is exiting as it was not connected to within 5 seconds.');
+        process.exit(1);
+    }
+}, 5000).unref();
 const exitHandler = (exitCode) => () => {
     server.close();
     try {