From 34cc9d289ee7e5d8951a4bade2f17a57096d2da2 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 7 May 2026 20:46:27 +0000 Subject: [PATCH 01/10] Initial plan From 2b21ff0e5f84b4a39a373888b68ca245a469fc4e Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 7 May 2026 20:53:45 +0000 Subject: [PATCH 02/10] Pass DOTNET_ROOT env overrides when launching MSBuild server node Mirror NodeProviderOutOfProc and pass the DOTNET_ROOT environment overrides produced by DotnetHostEnvironmentHelper to the launched server child process. When the parent MSBuild runs as the apphost (native exe), the server child also runs as the apphost and needs DOTNET_ROOT to find the runtime; without these overrides the server fails to start and the client times out connecting to its named pipe after 20 seconds. Fixes the regression hit by Aspire when it sets DOTNET_CLI_USE_MSBUILD_SERVER=true on .NET 10.0.300. Agent-Logs-Url: https://github.com/dotnet/msbuild/sessions/df1c30e2-3d1c-4518-9ed0-e1c08ef0151e Co-authored-by: rainersigwald <3347530+rainersigwald@users.noreply.github.com> --- src/Build/BackEnd/Client/MSBuildClient.cs | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/Build/BackEnd/Client/MSBuildClient.cs b/src/Build/BackEnd/Client/MSBuildClient.cs index c1073683256..cb2bd599de4 100644 --- a/src/Build/BackEnd/Client/MSBuildClient.cs +++ b/src/Build/BackEnd/Client/MSBuildClient.cs @@ -459,7 +459,20 @@ private bool TryLaunchServer() ]; NodeLauncher nodeLauncher = new NodeLauncher(); CommunicationsUtilities.Trace("Starting Server..."); - using Process msbuildProcess = nodeLauncher.Start(new NodeLaunchData(_msbuildLocation, string.Join(" ", msBuildServerOptions)), nodeId: 0); + + // Apply the same DOTNET_ROOT environment overrides we pass to worker nodes (see + // NodeProviderOutOfProc.CreateNode). When the parent MSBuild process is the + // apphost (native executable), the launched server child is also the apphost and + // needs DOTNET_ROOT to locate the runtime. Without these overrides the server + // process fails to start, the named pipe is never opened, and the client times + // out after 20s. See https://github.com/dotnet/msbuild/issues for the Aspire + // DOTNET_CLI_USE_MSBUILD_SERVER=true regression. + NodeLaunchData launchData = new( + MSBuildLocation: _msbuildLocation, + CommandLineArgs: string.Join(" ", msBuildServerOptions), + EnvironmentOverrides: DotnetHostEnvironmentHelper.CreateDotnetRootEnvironmentOverrides()!); + + using Process msbuildProcess = nodeLauncher.Start(launchData, nodeId: 0); CommunicationsUtilities.Trace($"Server started with PID: {msbuildProcess?.Id}"); } catch (Exception ex) From 9e1ddf4ee0260876223f13dff8e356d0bf5cafcb Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 7 May 2026 21:04:49 +0000 Subject: [PATCH 03/10] Improve server-launch diagnostics; fall back to in-proc on connect failure Two related changes that hardened the MSBuild server client path so the recent regression (Aspire + DOTNET_CLI_USE_MSBUILD_SERVER=true on .NET 10.0.300) cannot crash the CLI again: 1. MSBuildClient.TryConnectToServer now wraps the call to the underlying NodeProviderOutOfProcBase.TryConnectToPipeStream in a try/catch. NamedPipeClientStream.Connect throws TimeoutException when the pipe never becomes available (typically because the launched server child process failed to start, e.g. an apphost that can't locate the runtime). Previously this exception escaped MSBuildClient.Execute entirely (only IOException was caught), so MSBuildClientApp's in-proc fallback never got a chance to run and the user saw a System.TimeoutException after 20 seconds. The new catch also covers any non-critical exception (UnauthorizedAccessException, IOException, InvalidOperationException, ...) the same way NodeProviderOutOfProcBase.TryConnectToProcess already does. 2. A new LogConnectFailureDiagnostics helper reports the launched server PID and its current state (still running / exited with code N / no longer present) on every connect failure so MSBUILDDEBUGCOMM traces are immediately actionable, instead of just a generic "Failed to connect to server" line. 3. MSBuildClientApp now writes a single line to stderr when it falls back due to a server-side problem, suggesting DOTNET_ROOT and MSBUILDDEBUGCOMM=1 as next-step diagnostics. The well-understood ServerBusy race is still silent. Adds MSBuildClient_Tests.Execute_WithUnreachableServer_DoesNotPropagateException to lock in the contract that an unreachable server returns a recoverable MSBuildClientExitType rather than throwing. Agent-Logs-Url: https://github.com/dotnet/msbuild/sessions/df1c30e2-3d1c-4518-9ed0-e1c08ef0151e Co-authored-by: rainersigwald <3347530+rainersigwald@users.noreply.github.com> --- .../BackEnd/MSBuildClient_Tests.cs | 50 +++++++++++ src/Build/BackEnd/Client/MSBuildClient.cs | 86 ++++++++++++++++++- src/MSBuild/MSBuildClientApp.cs | 16 +++- 3 files changed, 147 insertions(+), 5 deletions(-) create mode 100644 src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs diff --git a/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs b/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs new file mode 100644 index 00000000000..e174b21c4bb --- /dev/null +++ b/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System.Threading; +using Microsoft.Build.Experimental; +using Shouldly; +using Xunit; + +#nullable disable + +namespace Microsoft.Build.Engine.UnitTests.BackEnd +{ + /// + /// Tests for the fallback behaviour. + /// + /// + /// Regression coverage for the .NET 10.0.300 / Aspire timeout: when + /// DOTNET_CLI_USE_MSBUILD_SERVER=true is honoured but the server child cannot start + /// (e.g. the apphost can't find the .NET runtime), must + /// not propagate a — it must return an exit type that + /// causes the host (MSBuildClientApp) to fall back to in-proc execution. + /// + public sealed class MSBuildClient_Tests + { + /// + /// When the configured msbuild executable does not exist, launching the server fails. + /// The client must report a recoverable exit type (LaunchError / UnableToConnect / + /// UnknownServerState / ServerBusy) rather than letting an exception escape. + /// + [Fact] + public void Execute_WithUnreachableServer_DoesNotPropagateException() + { + string[] commandLine = ["dummy.proj"]; + string nonexistentMsBuild = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "does-not-exist-" + System.Guid.NewGuid().ToString("N"), "MSBuild.dll"); + + MSBuildClient client = new MSBuildClient(commandLine, nonexistentMsBuild); + + // The whole point of the regression fix: this must NOT throw. Any of the recoverable + // exit types is acceptable here — what matters is that MSBuildClientApp gets a chance + // to fall back to in-proc execution. + MSBuildClientExitResult result = client.Execute(CancellationToken.None); + + result.MSBuildClientExitType.ShouldBeOneOf( + MSBuildClientExitType.LaunchError, + MSBuildClientExitType.UnableToConnect, + MSBuildClientExitType.UnknownServerState, + MSBuildClientExitType.ServerBusy); + } + } +} diff --git a/src/Build/BackEnd/Client/MSBuildClient.cs b/src/Build/BackEnd/Client/MSBuildClient.cs index cb2bd599de4..be4ff9bdfa6 100644 --- a/src/Build/BackEnd/Client/MSBuildClient.cs +++ b/src/Build/BackEnd/Client/MSBuildClient.cs @@ -101,6 +101,12 @@ public sealed class MSBuildClient /// private MSBuildClientPacketPump _packetPump = null!; + /// + /// PID of the server process this client launched (or null if no launch was attempted / + /// the server was already running). Used for diagnostics on connection failure. + /// + private int? _launchedServerPid; + /// /// Public constructor with parameters. /// @@ -473,7 +479,8 @@ private bool TryLaunchServer() EnvironmentOverrides: DotnetHostEnvironmentHelper.CreateDotnetRootEnvironmentOverrides()!); using Process msbuildProcess = nodeLauncher.Start(launchData, nodeId: 0); - CommunicationsUtilities.Trace($"Server started with PID: {msbuildProcess?.Id}"); + _launchedServerPid = msbuildProcess?.Id; + CommunicationsUtilities.Trace($"Server started with PID: {_launchedServerPid}"); } catch (Exception ex) { @@ -618,9 +625,36 @@ private bool TryConnectToServer(int timeoutMilliseconds) { tryAgain = false; + HandshakeResult result; + bool connected; + try + { + connected = NodeProviderOutOfProcBase.TryConnectToPipeStream( + _nodeStream, _pipeName, _handshake, Math.Max(1, timeoutMilliseconds - (int)sw.ElapsedMilliseconds), out result); + } + catch (TimeoutException) + { + // The underlying NamedPipeClientStream.Connect throws TimeoutException when the + // pipe never becomes available — typically because the server child process + // failed to start (e.g. apphost couldn't locate the runtime). Treat this as a + // recoverable connection failure so MSBuildClientApp can fall back to in-proc + // execution rather than crashing the whole CLI. + LogConnectFailureDiagnostics(timeoutMilliseconds, isTimeout: true, errorMessage: null); + _exitResult.MSBuildClientExitType = MSBuildClientExitType.UnableToConnect; + return false; + } + catch (Exception ex) when (!ExceptionHandling.IsCriticalException(ex)) + { + // Mirror the exception-tolerant behavior of NodeProviderOutOfProcBase.TryConnectToProcess + // so any non-critical failure (UnauthorizedAccessException, IOException, + // InvalidOperationException, etc.) routes through the standard fallback path + // rather than escaping out of MSBuildClient.Execute. + LogConnectFailureDiagnostics(timeoutMilliseconds, isTimeout: false, errorMessage: ex.Message); + _exitResult.MSBuildClientExitType = MSBuildClientExitType.UnableToConnect; + return false; + } - if (NodeProviderOutOfProcBase.TryConnectToPipeStream( - _nodeStream, _pipeName, _handshake, Math.Max(1, timeoutMilliseconds - (int)sw.ElapsedMilliseconds), out HandshakeResult result)) + if (connected) { return true; } @@ -636,7 +670,7 @@ private bool TryConnectToServer(int timeoutMilliseconds) } else { - CommunicationsUtilities.Trace($"Failed to connect to server: {result.ErrorMessage}"); + LogConnectFailureDiagnostics(timeoutMilliseconds, isTimeout: result.Status is HandshakeStatus.Timeout, errorMessage: result.ErrorMessage); _exitResult.MSBuildClientExitType = MSBuildClientExitType.UnableToConnect; return false; } @@ -646,6 +680,50 @@ private bool TryConnectToServer(int timeoutMilliseconds) return false; } + /// + /// Emits a single diagnostic trace entry describing why connection to the MSBuild server + /// failed, including the launched server PID (if any) and its current state. This makes + /// the otherwise-opaque 20s timeout actionable when MSBUILDDEBUGCOMM tracing is enabled. + /// + private void LogConnectFailureDiagnostics(int timeoutMilliseconds, bool isTimeout, string? errorMessage) + { + string serverState; + if (_launchedServerPid is int pid) + { + try + { + using Process? launched = Process.GetProcessById(pid); + serverState = launched is null + ? $"PID {pid} (no longer present)" + : launched.HasExited + ? $"PID {pid} (already exited with code {launched.ExitCode})" + : $"PID {pid} (still running)"; + } + catch (ArgumentException) + { + // Process already terminated and was reaped before we could query it. + serverState = $"PID {pid} (already exited)"; + } + catch (InvalidOperationException) + { + serverState = $"PID {pid} (state unavailable)"; + } + } + else + { + serverState = "no launch attempted (server reported as already running)"; + } + + string reason = isTimeout + ? $"timed out after {timeoutMilliseconds} ms waiting for the named pipe" + : $"connection error: {errorMessage}"; + + CommunicationsUtilities.Trace( + $"MSBuild server connection failed ({reason}). Launched server: {serverState}. " + + "Falling back to in-proc build. " + + "If the server child process exited immediately, ensure DOTNET_ROOT is set correctly so the apphost can locate the .NET runtime."); + } + private void WritePacket(Stream nodeStream, INodePacket packet) { MemoryStream memoryStream = _packetMemoryStream; diff --git a/src/MSBuild/MSBuildClientApp.cs b/src/MSBuild/MSBuildClientApp.cs index 33100583fe2..f607797c3cb 100644 --- a/src/MSBuild/MSBuildClientApp.cs +++ b/src/MSBuild/MSBuildClientApp.cs @@ -70,7 +70,21 @@ public static MSBuildApp.ExitType Execute(string[] commandLineArgs, string msbui KnownTelemetry.PartialBuildTelemetry.ServerFallbackReason = exitResult.MSBuildClientExitType.ToString(); } - // Server is busy, fallback to old behavior. + // Surface a single user-visible message on stderr when the failure is something + // other than the well-understood "another client is racing us for the launch + // mutex" case. Without this the user sees no indication that MSBuild Server was + // requested but unavailable; previously a connection timeout would even crash + // the process. See https://github.com/dotnet/msbuild/issues for the + // DOTNET_CLI_USE_MSBUILD_SERVER=true regression in 10.0.300. + if (exitResult.MSBuildClientExitType != MSBuildClientExitType.ServerBusy) + { + string detail = exitResult.MSBuildClientExitType == MSBuildClientExitType.UnableToConnect + ? "could not connect to the server (it may have failed to start; ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime, or set MSBUILDDEBUGCOMM=1 for diagnostics)" + : exitResult.MSBuildClientExitType.ToString(); + Console.Error.WriteLine($"MSBuild server unavailable ({detail}); falling back to in-proc build."); + } + + // Server is busy / unavailable, fallback to old behavior. return MSBuildApp.Execute(commandLineArgs); } From c84ecd1864e782e1468e680097ad65e93c2d743f Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Thu, 7 May 2026 21:08:28 +0000 Subject: [PATCH 04/10] Address review comments: drop placeholder issue link, enable nullable in new test Agent-Logs-Url: https://github.com/dotnet/msbuild/sessions/df1c30e2-3d1c-4518-9ed0-e1c08ef0151e Co-authored-by: rainersigwald <3347530+rainersigwald@users.noreply.github.com> --- src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs | 10 +++++----- src/Build/BackEnd/Client/MSBuildClient.cs | 3 +-- src/MSBuild/MSBuildClientApp.cs | 3 +-- 3 files changed, 7 insertions(+), 9 deletions(-) diff --git a/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs b/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs index e174b21c4bb..8a4e17f85f7 100644 --- a/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs +++ b/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs @@ -1,13 +1,13 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.IO; using System.Threading; using Microsoft.Build.Experimental; using Shouldly; using Xunit; -#nullable disable - namespace Microsoft.Build.Engine.UnitTests.BackEnd { /// @@ -17,7 +17,7 @@ namespace Microsoft.Build.Engine.UnitTests.BackEnd /// Regression coverage for the .NET 10.0.300 / Aspire timeout: when /// DOTNET_CLI_USE_MSBUILD_SERVER=true is honoured but the server child cannot start /// (e.g. the apphost can't find the .NET runtime), must - /// not propagate a — it must return an exit type that + /// not propagate a — it must return an exit type that /// causes the host (MSBuildClientApp) to fall back to in-proc execution. /// public sealed class MSBuildClient_Tests @@ -31,12 +31,12 @@ public sealed class MSBuildClient_Tests public void Execute_WithUnreachableServer_DoesNotPropagateException() { string[] commandLine = ["dummy.proj"]; - string nonexistentMsBuild = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "does-not-exist-" + System.Guid.NewGuid().ToString("N"), "MSBuild.dll"); + string nonexistentMsBuild = Path.Combine(Path.GetTempPath(), "does-not-exist-" + Guid.NewGuid().ToString("N"), "MSBuild.dll"); MSBuildClient client = new MSBuildClient(commandLine, nonexistentMsBuild); // The whole point of the regression fix: this must NOT throw. Any of the recoverable - // exit types is acceptable here — what matters is that MSBuildClientApp gets a chance + // exit types is acceptable here — what matters is that MSBuildClientApp gets a chance // to fall back to in-proc execution. MSBuildClientExitResult result = client.Execute(CancellationToken.None); diff --git a/src/Build/BackEnd/Client/MSBuildClient.cs b/src/Build/BackEnd/Client/MSBuildClient.cs index be4ff9bdfa6..19dc5e0c85f 100644 --- a/src/Build/BackEnd/Client/MSBuildClient.cs +++ b/src/Build/BackEnd/Client/MSBuildClient.cs @@ -471,8 +471,7 @@ private bool TryLaunchServer() // apphost (native executable), the launched server child is also the apphost and // needs DOTNET_ROOT to locate the runtime. Without these overrides the server // process fails to start, the named pipe is never opened, and the client times - // out after 20s. See https://github.com/dotnet/msbuild/issues for the Aspire - // DOTNET_CLI_USE_MSBUILD_SERVER=true regression. + // out after 20s (the DOTNET_CLI_USE_MSBUILD_SERVER=true regression in 10.0.300). NodeLaunchData launchData = new( MSBuildLocation: _msbuildLocation, CommandLineArgs: string.Join(" ", msBuildServerOptions), diff --git a/src/MSBuild/MSBuildClientApp.cs b/src/MSBuild/MSBuildClientApp.cs index f607797c3cb..71f9d78afdb 100644 --- a/src/MSBuild/MSBuildClientApp.cs +++ b/src/MSBuild/MSBuildClientApp.cs @@ -74,8 +74,7 @@ public static MSBuildApp.ExitType Execute(string[] commandLineArgs, string msbui // other than the well-understood "another client is racing us for the launch // mutex" case. Without this the user sees no indication that MSBuild Server was // requested but unavailable; previously a connection timeout would even crash - // the process. See https://github.com/dotnet/msbuild/issues for the - // DOTNET_CLI_USE_MSBUILD_SERVER=true regression in 10.0.300. + // the process (the DOTNET_CLI_USE_MSBUILD_SERVER=true regression in 10.0.300). if (exitResult.MSBuildClientExitType != MSBuildClientExitType.ServerBusy) { string detail = exitResult.MSBuildClientExitType == MSBuildClientExitType.UnableToConnect From 794f83f7f3c6befda95b0705c3e17e09a691eee9 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Fri, 8 May 2026 22:00:35 +0000 Subject: [PATCH 05/10] Address review: localize fallback messages, surface "server crashed" exit code, move regression docs onto test method - Add 6 new resource strings to src/MSBuild/Resources/Strings.resx (and regenerate all 13 .xlf files via /t:UpdateXlf): MSBuildServerUnavailable, MSBuildServerCrashedOnLaunch, MSBuildServerLaunchTimeout, MSBuildServerLaunchError, MSBuildServerStateUnknown, MSBuildServerConnectFailed. - Add public int? ServerProcessExitCode to MSBuildClientExitResult so MSBuildClient can structurally surface "server child exited immediately" to the host. MSBuildClient.LogConnectFailureDiagnostics populates it whenever the launched server PID has already exited. - MSBuildClientApp now picks the most specific localized sub-message for the "MSBuild server unavailable" notice, preferring the crashed-on-launch resource (with the exit code) over a generic timeout when the server's exit code is known. - Move the .NET 10.0.300 / Aspire regression description from the MSBuildClient_Tests class doc onto the Execute_WithUnreachableServer_DoesNotPropagateException test method so the class can host unrelated future tests. Agent-Logs-Url: https://github.com/dotnet/msbuild/sessions/e45700cf-4ff2-453a-bdda-757bf7ddde66 Co-authored-by: rainersigwald <3347530+rainersigwald@users.noreply.github.com> --- .../BackEnd/MSBuildClient_Tests.cs | 14 ++++----- src/Build/BackEnd/Client/MSBuildClient.cs | 21 +++++++++---- .../BackEnd/Client/MSBuildClientExitResult.cs | 9 ++++++ src/MSBuild/MSBuildClientApp.cs | 27 ++++++++++++++--- src/MSBuild/Resources/Strings.resx | 27 +++++++++++++++++ src/MSBuild/Resources/xlf/Strings.cs.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.de.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.es.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.fr.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.it.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.ja.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.ko.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.pl.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.pt-BR.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.ru.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.tr.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf | 30 +++++++++++++++++++ src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf | 30 +++++++++++++++++++ 18 files changed, 472 insertions(+), 16 deletions(-) diff --git a/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs b/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs index 8a4e17f85f7..6f92242d7bd 100644 --- a/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs +++ b/src/Build.UnitTests/BackEnd/MSBuildClient_Tests.cs @@ -13,13 +13,6 @@ namespace Microsoft.Build.Engine.UnitTests.BackEnd /// /// Tests for the fallback behaviour. /// - /// - /// Regression coverage for the .NET 10.0.300 / Aspire timeout: when - /// DOTNET_CLI_USE_MSBUILD_SERVER=true is honoured but the server child cannot start - /// (e.g. the apphost can't find the .NET runtime), must - /// not propagate a — it must return an exit type that - /// causes the host (MSBuildClientApp) to fall back to in-proc execution. - /// public sealed class MSBuildClient_Tests { /// @@ -27,6 +20,13 @@ public sealed class MSBuildClient_Tests /// The client must report a recoverable exit type (LaunchError / UnableToConnect / /// UnknownServerState / ServerBusy) rather than letting an exception escape. /// + /// + /// Regression coverage for the .NET 10.0.300 / Aspire timeout: when + /// DOTNET_CLI_USE_MSBUILD_SERVER=true is honoured but the server child cannot start + /// (e.g. the apphost can't find the .NET runtime), must + /// not propagate a — it must return an exit type that + /// causes the host (MSBuildClientApp) to fall back to in-proc execution. + /// [Fact] public void Execute_WithUnreachableServer_DoesNotPropagateException() { diff --git a/src/Build/BackEnd/Client/MSBuildClient.cs b/src/Build/BackEnd/Client/MSBuildClient.cs index 19dc5e0c85f..36874b8d590 100644 --- a/src/Build/BackEnd/Client/MSBuildClient.cs +++ b/src/Build/BackEnd/Client/MSBuildClient.cs @@ -683,6 +683,9 @@ private bool TryConnectToServer(int timeoutMilliseconds) /// Emits a single diagnostic trace entry describing why connection to the MSBuild server /// failed, including the launched server PID (if any) and its current state. This makes /// the otherwise-opaque 20s timeout actionable when MSBUILDDEBUGCOMM tracing is enabled. + /// Also populates when the + /// launched server child has already exited, so the host can surface that fact to the + /// user-visible "falling back to in-proc" message instead of a generic timeout. /// private void LogConnectFailureDiagnostics(int timeoutMilliseconds, bool isTimeout, string? errorMessage) { @@ -692,11 +695,19 @@ private void LogConnectFailureDiagnostics(int timeoutMilliseconds, bool isTimeou try { using Process? launched = Process.GetProcessById(pid); - serverState = launched is null - ? $"PID {pid} (no longer present)" - : launched.HasExited - ? $"PID {pid} (already exited with code {launched.ExitCode})" - : $"PID {pid} (still running)"; + if (launched is null) + { + serverState = $"PID {pid} (no longer present)"; + } + else if (launched.HasExited) + { + _exitResult.ServerProcessExitCode = launched.ExitCode; + serverState = $"PID {pid} (already exited with code {launched.ExitCode})"; + } + else + { + serverState = $"PID {pid} (still running)"; + } } catch (ArgumentException) { diff --git a/src/Build/BackEnd/Client/MSBuildClientExitResult.cs b/src/Build/BackEnd/Client/MSBuildClientExitResult.cs index ef58bba7517..76cf5d9ed4c 100644 --- a/src/Build/BackEnd/Client/MSBuildClientExitResult.cs +++ b/src/Build/BackEnd/Client/MSBuildClientExitResult.cs @@ -20,5 +20,14 @@ public sealed class MSBuildClientExitResult /// This field is null if MSBuild client execution was not successful. /// public string? MSBuildAppExitTypeString { get; set; } + + /// + /// When this client launched a server child process and that process had already exited + /// by the time we observed the connection failure, this is its exit code. null + /// otherwise (server still running, never launched, or its state could not be queried). + /// Hosts use this to surface "server crashed immediately on launch" to the user instead + /// of a generic timeout message. + /// + public int? ServerProcessExitCode { get; set; } } } diff --git a/src/MSBuild/MSBuildClientApp.cs b/src/MSBuild/MSBuildClientApp.cs index 71f9d78afdb..32409b102fa 100644 --- a/src/MSBuild/MSBuildClientApp.cs +++ b/src/MSBuild/MSBuildClientApp.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System; +using System.Globalization; using System.Threading; using Microsoft.Build.Experimental; using Microsoft.Build.Framework.Telemetry; @@ -77,10 +78,8 @@ public static MSBuildApp.ExitType Execute(string[] commandLineArgs, string msbui // the process (the DOTNET_CLI_USE_MSBUILD_SERVER=true regression in 10.0.300). if (exitResult.MSBuildClientExitType != MSBuildClientExitType.ServerBusy) { - string detail = exitResult.MSBuildClientExitType == MSBuildClientExitType.UnableToConnect - ? "could not connect to the server (it may have failed to start; ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime, or set MSBUILDDEBUGCOMM=1 for diagnostics)" - : exitResult.MSBuildClientExitType.ToString(); - Console.Error.WriteLine($"MSBuild server unavailable ({detail}); falling back to in-proc build."); + string detail = GetServerFallbackDetail(exitResult); + Console.Error.WriteLine(ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("MSBuildServerUnavailable", detail)); } // Server is busy / unavailable, fallback to old behavior. @@ -97,5 +96,25 @@ public static MSBuildApp.ExitType Execute(string[] commandLineArgs, string msbui return MSBuildApp.ExitType.MSBuildClientFailure; } + + /// + /// Picks the most specific localized "why MSBuild server was unavailable" sub-message for + /// the user-visible fallback notice. Prefers the "server crashed immediately on launch" + /// detail over a generic timeout when the launched server's exit code is known. + /// + private static string GetServerFallbackDetail(MSBuildClientExitResult exitResult) + { + return exitResult.MSBuildClientExitType switch + { + MSBuildClientExitType.LaunchError => AssemblyResources.GetString("MSBuildServerLaunchError"), + MSBuildClientExitType.UnknownServerState => AssemblyResources.GetString("MSBuildServerStateUnknown"), + MSBuildClientExitType.UnableToConnect when exitResult.ServerProcessExitCode is int code => + ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword( + "MSBuildServerCrashedOnLaunch", + code.ToString(CultureInfo.InvariantCulture)), + MSBuildClientExitType.UnableToConnect => AssemblyResources.GetString("MSBuildServerLaunchTimeout"), + _ => AssemblyResources.GetString("MSBuildServerConnectFailed"), + }; + } } } diff --git a/src/MSBuild/Resources/Strings.resx b/src/MSBuild/Resources/Strings.resx index b2e5738fac1..6a2a1735b4a 100644 --- a/src/MSBuild/Resources/Strings.resx +++ b/src/MSBuild/Resources/Strings.resx @@ -1736,6 +1736,33 @@ + + + MSBuild server unavailable: {0} Falling back to in-proc build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + + + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). + LOCALIZATION: {0} is the integer process exit code. + + + the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). + LOCALIZATION: No format arguments. + + + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). + LOCALIZATION: No format arguments. + + + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). + LOCALIZATION: No format arguments. + + + could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). + LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + + + - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.cs.xlf b/src/MSBuild/Resources/xlf/Strings.cs.xlf index 72d92deca15..cf9919c28ec 100644 --- a/src/MSBuild/Resources/xlf/Strings.cs.xlf +++ b/src/MSBuild/Resources/xlf/Strings.cs.xlf @@ -381,34 +381,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.de.xlf b/src/MSBuild/Resources/xlf/Strings.de.xlf index b10c5867d77..589a8cecf42 100644 --- a/src/MSBuild/Resources/xlf/Strings.de.xlf +++ b/src/MSBuild/Resources/xlf/Strings.de.xlf @@ -381,34 +381,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.es.xlf b/src/MSBuild/Resources/xlf/Strings.es.xlf index c8be2d42b27..ae7ddf582e5 100644 --- a/src/MSBuild/Resources/xlf/Strings.es.xlf +++ b/src/MSBuild/Resources/xlf/Strings.es.xlf @@ -380,34 +380,29 @@ Esta marca es experimental y puede que no funcione según lo previsto. - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.fr.xlf b/src/MSBuild/Resources/xlf/Strings.fr.xlf index 9bde5cb6c23..5cadffdd4c1 100644 --- a/src/MSBuild/Resources/xlf/Strings.fr.xlf +++ b/src/MSBuild/Resources/xlf/Strings.fr.xlf @@ -381,34 +381,29 @@ futures - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.it.xlf b/src/MSBuild/Resources/xlf/Strings.it.xlf index 64a5c56f24c..5a696871886 100644 --- a/src/MSBuild/Resources/xlf/Strings.it.xlf +++ b/src/MSBuild/Resources/xlf/Strings.it.xlf @@ -381,34 +381,29 @@ Questo flag è sperimentale e potrebbe non funzionare come previsto. - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.ja.xlf b/src/MSBuild/Resources/xlf/Strings.ja.xlf index d4c19ea04f4..b4f25914d2d 100644 --- a/src/MSBuild/Resources/xlf/Strings.ja.xlf +++ b/src/MSBuild/Resources/xlf/Strings.ja.xlf @@ -381,34 +381,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.ko.xlf b/src/MSBuild/Resources/xlf/Strings.ko.xlf index f40132cc433..6b585f26fa2 100644 --- a/src/MSBuild/Resources/xlf/Strings.ko.xlf +++ b/src/MSBuild/Resources/xlf/Strings.ko.xlf @@ -382,34 +382,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.pl.xlf b/src/MSBuild/Resources/xlf/Strings.pl.xlf index 5555e8f2453..e9df8852680 100644 --- a/src/MSBuild/Resources/xlf/Strings.pl.xlf +++ b/src/MSBuild/Resources/xlf/Strings.pl.xlf @@ -380,34 +380,29 @@ Ta flaga jest eksperymentalna i może nie działać zgodnie z oczekiwaniami. - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf b/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf index 510ffab5bf4..5725c7725ab 100644 --- a/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf +++ b/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf @@ -380,34 +380,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.ru.xlf b/src/MSBuild/Resources/xlf/Strings.ru.xlf index 8b0f6b3a495..ba1537109a2 100644 --- a/src/MSBuild/Resources/xlf/Strings.ru.xlf +++ b/src/MSBuild/Resources/xlf/Strings.ru.xlf @@ -380,34 +380,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.tr.xlf b/src/MSBuild/Resources/xlf/Strings.tr.xlf index 353a057300e..af8e8398a52 100644 --- a/src/MSBuild/Resources/xlf/Strings.tr.xlf +++ b/src/MSBuild/Resources/xlf/Strings.tr.xlf @@ -380,34 +380,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf b/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf index ab30f446270..16eae1438f5 100644 --- a/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf +++ b/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf @@ -381,34 +381,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} diff --git a/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf b/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf index e273dc608a0..d9951b78bda 100644 --- a/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf +++ b/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf @@ -381,34 +381,29 @@ - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - could not connect to the server (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. Used when no specific cause has been identified for a connection failure. + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: {0} is the integer process exit code. + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. - - - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - the server process did not respond in time and may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics). - LOCALIZATION: No format arguments. + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - MSBuild server unavailable: {0} Falling back to in-proc build. - MSBuild server unavailable: {0} Falling back to in-proc build. - LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used (e.g. that it crashed or did not respond). It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchTimeout / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. + MSBuild server unavailable: {0}. Falling back to an in-process build. + MSBuild server unavailable: {0}. Falling back to an in-process build. + LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. MSBuild version {0} for {1} From 3df368f8f6eb6cd34854928140b630dffc5dea61 Mon Sep 17 00:00:00 2001 From: Rainer Sigwald Date: Wed, 13 May 2026 15:24:54 -0500 Subject: [PATCH 07/10] Condense DOTNET_ROOT comment in MSBuildClient.TryLaunchServer MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The launch-time DOTNET_ROOT override is replaced wholesale by the client's environment on the first build command (OutOfProcServerNode.HandleServerNodeBuildCommand calls CommunicationsUtilities.SetEnvironment, which deletes any var not in the client env). The full background — worker-node parity, the apphost runtime-resolution failure mode, and the nullability suppression rationale — is now tracked in dotnet/msbuild#13761; the inline block comment can be much shorter. Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- src/Build/BackEnd/Client/MSBuildClient.cs | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-) diff --git a/src/Build/BackEnd/Client/MSBuildClient.cs b/src/Build/BackEnd/Client/MSBuildClient.cs index 090064a2926..2413ec2f7d7 100644 --- a/src/Build/BackEnd/Client/MSBuildClient.cs +++ b/src/Build/BackEnd/Client/MSBuildClient.cs @@ -466,19 +466,10 @@ private bool TryLaunchServer() NodeLauncher nodeLauncher = new NodeLauncher(); CommunicationsUtilities.Trace("Starting Server..."); - // Apply the same DOTNET_ROOT environment overrides we pass to worker nodes (see - // NodeProviderOutOfProc.CreateNode). When the parent MSBuild process is the - // apphost (native executable), the launched server child is also the apphost and - // needs DOTNET_ROOT to locate the runtime. Without these overrides the server - // process fails to start, the named pipe is never opened, and the client times - // out after 20s (the DOTNET_CLI_USE_MSBUILD_SERVER=true regression in 10.0.300). - // The `!` is a type-variance suppression: CreateDotnetRootEnvironmentOverrides() - // returns IDictionary?, but NodeLaunchData.EnvironmentOverrides - // is typed IDictionary?. NodeProviderOutOfProc.cs:102 hides the - // same mismatch via #nullable disable on that file; this file has nullable - // enabled so the suppression is required to compile. The dictionary's null - // values are intentional sentinels (clear architecture-specific DOTNET_ROOT_* - // overrides) and are honoured by ApplyEnvironmentOverrides. + // Set DOTNET_ROOT so the apphost server child can locate the runtime; this + // override is replaced by the client's environment on the first build command + // (see OutOfProcServerNode.HandleServerNodeBuildCommand → SetEnvironment). + // The `!` works around dotnet/msbuild#13761. NodeLaunchData launchData = new( MSBuildLocation: _msbuildLocation, CommandLineArgs: string.Join(" ", msBuildServerOptions), From 6c378ce6a4e563534b486a2cf65edc31339db9dc Mon Sep 17 00:00:00 2001 From: Rainer Sigwald Date: Wed, 13 May 2026 15:31:59 -0500 Subject: [PATCH 08/10] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- src/Build/BackEnd/Client/MSBuildClient.cs | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/Build/BackEnd/Client/MSBuildClient.cs b/src/Build/BackEnd/Client/MSBuildClient.cs index 2413ec2f7d7..6cf69e8705b 100644 --- a/src/Build/BackEnd/Client/MSBuildClient.cs +++ b/src/Build/BackEnd/Client/MSBuildClient.cs @@ -692,12 +692,8 @@ private void LogConnectFailureDiagnostics(int timeoutMilliseconds, bool isTimeou { try { - using Process? launched = Process.GetProcessById(pid); - if (launched is null) - { - serverState = $"PID {pid} (no longer present)"; - } - else if (launched.HasExited) + using Process launched = Process.GetProcessById(pid); + if (launched.HasExited) { _exitResult.ServerProcessExitCode = launched.ExitCode; serverState = $"PID {pid} (already exited with code {launched.ExitCode})"; From e38dea653cdbdff437c0a282a421d5cbae33615d Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Wed, 13 May 2026 20:37:46 +0000 Subject: [PATCH 09/10] Remove MSBUILDDEBUGCOMM mention and apply suggested wording in fallback strings MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Per review feedback: - Remove the "set MSBUILDDEBUGCOMM=1 for diagnostics" parenthetical from all four user-facing fallback sub-messages — that's a private MSBuild env var and should not be surfaced to end users. - Apply @rainersigwald's suggested wording verbatim: MSBuildServerCrashedOnLaunch -> "the server process exited with code {0} immediately after launch" MSBuildServerConnectFailed -> "could not connect to the server within the timeout window; the server may have failed to start" - Trim the now-unnecessary DOTNET_ROOT hint from MSBuildServerConnectFailed for consistency with the other sub-messages. - Regenerate all 13 .xlf files via /t:UpdateXlf so localization is re-flagged for re-translation. Agent-Logs-Url: https://github.com/dotnet/msbuild/sessions/d4e10810-b7e2-48db-acf5-9370f8ca9125 Co-authored-by: rainersigwald <3347530+rainersigwald@users.noreply.github.com> --- src/MSBuild/Resources/Strings.resx | 8 ++++---- src/MSBuild/Resources/xlf/Strings.cs.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.de.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.es.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.fr.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.it.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.ja.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.ko.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.pl.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.pt-BR.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.ru.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.tr.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf | 16 ++++++++-------- src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf | 16 ++++++++-------- 14 files changed, 108 insertions(+), 108 deletions(-) diff --git a/src/MSBuild/Resources/Strings.resx b/src/MSBuild/Resources/Strings.resx index c63c3a7ac70..1eae13c5f5b 100644 --- a/src/MSBuild/Resources/Strings.resx +++ b/src/MSBuild/Resources/Strings.resx @@ -1742,19 +1742,19 @@ LOCALIZATION: {0} is a sub-message describing why the MSBuild server could not be used. It is one of MSBuildServerCrashedOnLaunch / MSBuildServerLaunchError / MSBuildServerStateUnknown / MSBuildServerConnectFailed. The outer template supplies the trailing period after {0}; sub-messages must NOT end with a period or other sentence-final punctuation. - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.cs.xlf b/src/MSBuild/Resources/xlf/Strings.cs.xlf index cf9919c28ec..8355d9c3fef 100644 --- a/src/MSBuild/Resources/xlf/Strings.cs.xlf +++ b/src/MSBuild/Resources/xlf/Strings.cs.xlf @@ -381,23 +381,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.de.xlf b/src/MSBuild/Resources/xlf/Strings.de.xlf index 589a8cecf42..f7435149433 100644 --- a/src/MSBuild/Resources/xlf/Strings.de.xlf +++ b/src/MSBuild/Resources/xlf/Strings.de.xlf @@ -381,23 +381,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.es.xlf b/src/MSBuild/Resources/xlf/Strings.es.xlf index ae7ddf582e5..df14f928a1f 100644 --- a/src/MSBuild/Resources/xlf/Strings.es.xlf +++ b/src/MSBuild/Resources/xlf/Strings.es.xlf @@ -380,23 +380,23 @@ Esta marca es experimental y puede que no funcione según lo previsto. - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.fr.xlf b/src/MSBuild/Resources/xlf/Strings.fr.xlf index 5cadffdd4c1..b2897d1fb05 100644 --- a/src/MSBuild/Resources/xlf/Strings.fr.xlf +++ b/src/MSBuild/Resources/xlf/Strings.fr.xlf @@ -381,23 +381,23 @@ futures - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.it.xlf b/src/MSBuild/Resources/xlf/Strings.it.xlf index 5a696871886..17611baab1a 100644 --- a/src/MSBuild/Resources/xlf/Strings.it.xlf +++ b/src/MSBuild/Resources/xlf/Strings.it.xlf @@ -381,23 +381,23 @@ Questo flag è sperimentale e potrebbe non funzionare come previsto. - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.ja.xlf b/src/MSBuild/Resources/xlf/Strings.ja.xlf index b4f25914d2d..5326f2c45a2 100644 --- a/src/MSBuild/Resources/xlf/Strings.ja.xlf +++ b/src/MSBuild/Resources/xlf/Strings.ja.xlf @@ -381,23 +381,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.ko.xlf b/src/MSBuild/Resources/xlf/Strings.ko.xlf index 6b585f26fa2..d2103a08ccd 100644 --- a/src/MSBuild/Resources/xlf/Strings.ko.xlf +++ b/src/MSBuild/Resources/xlf/Strings.ko.xlf @@ -382,23 +382,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.pl.xlf b/src/MSBuild/Resources/xlf/Strings.pl.xlf index e9df8852680..a57b0e34648 100644 --- a/src/MSBuild/Resources/xlf/Strings.pl.xlf +++ b/src/MSBuild/Resources/xlf/Strings.pl.xlf @@ -380,23 +380,23 @@ Ta flaga jest eksperymentalna i może nie działać zgodnie z oczekiwaniami. - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf b/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf index 5725c7725ab..0f2b77ee68c 100644 --- a/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf +++ b/src/MSBuild/Resources/xlf/Strings.pt-BR.xlf @@ -380,23 +380,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.ru.xlf b/src/MSBuild/Resources/xlf/Strings.ru.xlf index ba1537109a2..d39f458ddab 100644 --- a/src/MSBuild/Resources/xlf/Strings.ru.xlf +++ b/src/MSBuild/Resources/xlf/Strings.ru.xlf @@ -380,23 +380,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.tr.xlf b/src/MSBuild/Resources/xlf/Strings.tr.xlf index af8e8398a52..60753f669a3 100644 --- a/src/MSBuild/Resources/xlf/Strings.tr.xlf +++ b/src/MSBuild/Resources/xlf/Strings.tr.xlf @@ -380,23 +380,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf b/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf index 16eae1438f5..e47479a7583 100644 --- a/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf +++ b/src/MSBuild/Resources/xlf/Strings.zh-Hans.xlf @@ -381,23 +381,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). diff --git a/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf b/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf index d9951b78bda..a3c054b5f8c 100644 --- a/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf +++ b/src/MSBuild/Resources/xlf/Strings.zh-Hant.xlf @@ -381,23 +381,23 @@ - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - could not connect to the server within the timeout window; the server may have failed to start (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + could not connect to the server within the timeout window; the server may have failed to start + could not connect to the server within the timeout window; the server may have failed to start LOCALIZATION: No format arguments. Used for any connect failure when the server's exit code is not known — covers both pipe-connect timeouts and non-timeout I/O errors during the connect attempt. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process exited with code {0} immediately after launch (ensure DOTNET_ROOT is set so the apphost can locate the .NET runtime; set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process exited with code {0} immediately after launch + the server process exited with code {0} immediately after launch LOCALIZATION: {0} is the integer process exit code; rendered with InvariantCulture as a decimal integer, do not localize the digits. This message is concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) - the server process could not be launched (set MSBUILDDEBUGCOMM=1 for diagnostics) + the server process could not be launched + the server process could not be launched LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) - the current server state could not be determined (set MSBUILDDEBUGCOMM=1 for diagnostics) + the current server state could not be determined + the current server state could not be determined LOCALIZATION: No format arguments. Concatenated mid-sentence after a colon in MSBuildServerUnavailable: lower-case start in English is intentional and the message must NOT end with a period (the outer template adds it). From c5a09b3effb98aaab9bd1ac16d1d180c8de01202 Mon Sep 17 00:00:00 2001 From: Rainer Sigwald Date: Wed, 13 May 2026 15:41:20 -0500 Subject: [PATCH 10/10] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- src/Build/BackEnd/Client/MSBuildClient.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Build/BackEnd/Client/MSBuildClient.cs b/src/Build/BackEnd/Client/MSBuildClient.cs index 6cf69e8705b..4c6a61fb362 100644 --- a/src/Build/BackEnd/Client/MSBuildClient.cs +++ b/src/Build/BackEnd/Client/MSBuildClient.cs @@ -476,7 +476,7 @@ private bool TryLaunchServer() EnvironmentOverrides: DotnetHostEnvironmentHelper.CreateDotnetRootEnvironmentOverrides()!); using Process msbuildProcess = nodeLauncher.Start(launchData, nodeId: 0); - _launchedServerPid = msbuildProcess?.Id; + _launchedServerPid = msbuildProcess.Id; CommunicationsUtilities.Trace($"Server started with PID: {_launchedServerPid}"); } catch (Exception ex)