Fix Unix/macOS node reuse bugs + reduce idle timeout

src/Build.UnitTests/BackEnd/UnixNodeReuseFixes_Tests.cs

@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#if NET
+
+using Microsoft.Build.Internal;
+using Microsoft.Build.Shared;
+using Shouldly;
+using Xunit;
+
+namespace Microsoft.Build.UnitTests
+{
+    /// <summary>
+    /// Tests for Unix node reuse bug fixes:
+    /// - SessionId = 0 on Unix (cross-terminal node reuse)
+    /// </summary>
+    public class UnixNodeReuseFixes_Tests
+    {
+        [Fact]
+        public void Handshake_OnUnix_SessionIdIsZero()
+        {
+            if (!NativeMethodsShared.IsUnixLike)
+            {
+                return;
+            }
+
+            // Two handshakes created from different contexts should have the same
+            // session ID (0) on Unix, enabling cross-terminal node reuse.
+            var h1 = new Handshake(HandshakeOptions.NodeReuse);
+            var h2 = new Handshake(HandshakeOptions.NodeReuse);
+
+            // Same handshake key means same session ID was used
+            h1.GetKey().ShouldBe(h2.GetKey());
+        }
+
+        [Fact]
+        public void Handshake_SessionIdComponent_IsZeroOnUnix()
+        {
+            if (!NativeMethodsShared.IsUnixLike)
+            {
+                return;
+            }
+
+            var handshake = new Handshake(HandshakeOptions.NodeReuse);
+
+            // Key format: "options salt major minor build private sessionId"
+            // Last component should be 0 on Unix
+            string key = handshake.GetKey();
+            string[] keyParts = key.Split(' ');
+            keyParts[keyParts.Length - 1].ShouldBe("0");
+        }
+    }
+}
+
+#endif

src/Build/BackEnd/Components/Communications/NodeProviderOutOfProcBase.cs

@@ -49,6 +49,12 @@ internal abstract partial class NodeProviderOutOfProcBase
         /// </summary>
         private const int TimeoutForNewNodeCreation = 30000;
 
+        /// <summary>
+        /// The amount of time to wait when attempting to reuse an existing idle node.
+        /// Must be long enough for a sleeping node to wake and respond to the handshake.
+        /// </summary>
+        private const int TimeoutForNodeReuse = 1000;
+
         /// <summary>
         /// The amount of time to wait for an out-of-proc node to exit.
         /// </summary>
@@ -318,7 +324,7 @@ bool TryReuseAnyFromPossibleRunningNodes(int currentProcessId, int nodeId)
                     _processesToIgnore.TryAdd(nodeLookupKey, default);
 
                     // Attempt to connect to each process in turn.
-                    Stream nodeStream = TryConnectToProcess(nodeToReuse.Id, 0 /* poll, don't wait for connections */, nodeLaunchData.Handshake, out HandshakeResult result);
+                    Stream nodeStream = TryConnectToProcess(nodeToReuse.Id, TimeoutForNodeReuse, nodeLaunchData.Handshake, out HandshakeResult result);
                     if (nodeStream != null)
                     {
                         // Connection successful, use this node.

src/Shared/CommunicationsUtilities.cs

@@ -289,8 +289,14 @@ protected Handshake(HandshakeOptions nodeType, bool includeSessionId, string too
             int sessionId = 0;
             if (includeSessionId)
             {
-                using var currentProcess = Process.GetCurrentProcess();
-                sessionId = currentProcess.SessionId;
+                if (NativeMethodsShared.IsWindows)
+                {
+                    using var currentProcess = Process.GetCurrentProcess();
+                    sessionId = currentProcess.SessionId;
+                }
+                // On Unix, getsid() returns the session leader PID which differs per terminal,
+                // preventing cross-terminal node reuse. Use 0 since Unix doesn't need
+                // RDP-style session isolation.
             }
 
             _handshakeComponents = IsNetTaskHost
@@ -409,7 +415,7 @@ internal static class CommunicationsUtilities
         /// <summary>
         /// The timeout to connect to a node.
         /// </summary>
-        private const int DefaultNodeConnectionTimeout = 900 * 1000; // 15 minutes; enough time that a dev will typically do another build in this time
+        private const int DefaultNodeConnectionTimeout = 30 * 1000; // 30 seconds
 
         /// <summary>
         /// Whether to trace communications

src/Shared/NodeEndpointOutOfProcBase.cs

@@ -44,8 +44,10 @@ internal abstract class NodeEndpointOutOfProcBase : INodeEndpoint
 #if NETCOREAPP2_1_OR_GREATER
         /// <summary>
         /// The amount of time to wait for the client to connect to the host.
+        /// Reduced from 60s to 5s so that failed reuse probes don't block idle nodes
+        /// from reaching their connection timeout check.
         /// </summary>
-        private const int ClientConnectTimeout = 60000;
+        private const int ClientConnectTimeout = 5000;
 #endif // NETCOREAPP2_1
 
         /// <summary>