Shutdown build servers via named pipes

Directory.Packages.props

@@ -52,6 +52,7 @@
     <PackageVersion Include="Microsoft.FSharp.Compiler" Version="$(MicrosoftFSharpCompilerPackageVersion)" />
     <PackageVersion Include="Microsoft.Net.Compilers.Toolset.Framework" Version="$(MicrosoftNetCompilersToolsetFrameworkPackageVersion)" />
     <PackageVersion Include="Microsoft.Management.Infrastructure" Version="3.0.0" />
+    <PackageVersion Include="Microsoft.Net.BuildServerUtils" Version="$(MicrosoftNetBuildServerUtilsVersion)" />
     <PackageVersion Include="Microsoft.NET.HostModel" Version="$(MicrosoftNETHostModelVersion)" />
     <PackageVersion Include="Microsoft.NET.Sdk.Razor.SourceGenerators.Transport" Version="$(MicrosoftNETSdkRazorSourceGeneratorsTransportPackageVersion)" />
     <PackageVersion Include="Microsoft.NETCore.App.Runtime.win-x86" Version="$(MicrosoftNETCoreAppRuntimePackageVersion)" />

eng/Versions.props

@@ -213,6 +213,7 @@
   </PropertyGroup>
   <PropertyGroup>
     <!-- Dependencies from https://github.com/dotnet/roslyn -->
+    <MicrosoftNetBuildServerUtilsVersion>5.0.0-1.25359.101</MicrosoftNetBuildServerUtilsVersion>
     <MicrosoftNetCompilersToolsetVersion>5.0.0-1.25359.101</MicrosoftNetCompilersToolsetVersion>
     <MicrosoftNetCompilersToolsetFrameworkPackageVersion>5.0.0-1.25359.101</MicrosoftNetCompilersToolsetFrameworkPackageVersion>
     <MicrosoftCodeAnalysisPackageVersion>5.0.0-1.25359.101</MicrosoftCodeAnalysisPackageVersion>

src/Cli/Microsoft.DotNet.Cli.Utils/MSBuildForwardingAppWithoutLogging.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using Microsoft.DotNet.Cli.Utils.Extensions;
 using Microsoft.DotNet.Cli;
+using Microsoft.Net.BuildServerUtils;
 
 namespace Microsoft.DotNet.Cli.Utils;
 
@@ -70,6 +71,8 @@ public MSBuildForwardingAppWithoutLogging(MSBuildArgs msbuildArgs, string? msbui
 
         EnvironmentVariable("MSBUILDUSESERVER", UseMSBuildServer ? "1" : "0");
 
+        EnvironmentVariable(BuildServerUtility.DotNetHostServerPath, GetHostServerPath());
+
         // If DOTNET_CLI_RUN_MSBUILD_OUTOFPROC is set or we're asked to execute a non-default binary, call MSBuild out-of-proc.
         if (AlwaysExecuteMSBuildOutOfProc || !string.Equals(MSBuildPath, defaultMSBuildPath, StringComparison.OrdinalIgnoreCase))
         {
@@ -135,6 +138,24 @@ public void EnvironmentVariable(string name, string? value)
         }
     }
 
+
+    public static string GetHostServerPath()
+    {
+        // If the path is set from outside, reuse it.
+        var hostServerPath = Env.GetEnvironmentVariable(BuildServerUtility.DotNetHostServerPath);
+        if (string.IsNullOrWhiteSpace(hostServerPath))
+        {
+            // Otherwise, construct a directory path under temp.
+            string baseDirectory = PathUtility.GetUserRestrictedTempDirectory();
+            hostServerPath = Path.Join(baseDirectory, "dotnet", "server", Product.TargetFrameworkVersion);
+        }
+
+        // Create the directory.
+        PathUtility.CreateUserRestrictedDirectory(hostServerPath);
+
+        return hostServerPath;
+    }
+
     public int Execute()
     {
         if (_forwardingApp != null)

src/Cli/Microsoft.DotNet.Cli.Utils/Microsoft.DotNet.Cli.Utils.csproj

@@ -53,6 +53,7 @@
     <PackageReference Include="NuGet.ProjectModel" />
     <PackageReference Include="Microsoft.Build" ExcludeAssets="runtime" PrivateAssets="all" />
     <PackageReference Include="Microsoft.Build.Utilities.Core" ExcludeAssets="runtime" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.Net.BuildServerUtils" />
     <PackageReference Include="System.CommandLine" />
     <PackageReference Include="System.Diagnostics.DiagnosticSource" />
     <PackageReference Include="System.IO.Hashing" />

src/Cli/Microsoft.DotNet.Cli.Utils/PathUtility.cs

@@ -89,6 +89,27 @@ public static void EnsureDirectoryExists(string? directoryPath)
         }
     }
 
+    public static string GetUserRestrictedTempDirectory()
+    {
+        // We want a location where permissions are expected to be restricted to the current user.
+        return RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
+            ? Path.GetTempPath()
+            : Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+    }
+
+    public static void CreateUserRestrictedDirectory(string path)
+    {
+        if (OperatingSystem.IsWindows())
+        {
+            Directory.CreateDirectory(path);
+        }
+        else
+        {
+            // NOTE: This modifies the permissions if needed, and throws if not possible.
+            Directory.CreateDirectory(path, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
+        }
+    }
+
     public static bool TryDeleteDirectory(string directoryPath)
     {
         try

src/Cli/Microsoft.DotNet.Cli.Utils/Product.cs

@@ -5,18 +5,32 @@
 
 namespace Microsoft.DotNet.Cli.Utils;
 
-public class Product
+public static class Product
 {
     public static string LongName => LocalizableStrings.DotNetSdkInfo;
-    public static readonly string Version = GetProductVersion();
+    public static readonly string Version;
+    public static readonly string TargetFrameworkVersion;
 
-    private static string GetProductVersion()
+    static Product()
     {
         DotnetVersionFile versionFile = DotnetFiles.VersionFileObject;
-        return versionFile.BuildNumber ??
+        Version = versionFile.BuildNumber ??
                 System.Diagnostics.FileVersionInfo.GetVersionInfo(
                         typeof(Product).GetTypeInfo().Assembly.Location)
                     .ProductVersion ??
                 string.Empty;
+
+        int firstDotIndex = Version.IndexOf('.');
+        if (firstDotIndex >= 0)
+        {
+            int secondDotIndex = Version.IndexOf('.', firstDotIndex + 1);
+            TargetFrameworkVersion = secondDotIndex >= 0
+                ? Version.Substring(0, secondDotIndex)
+                : Version;
+        }
+        else
+        {
+            TargetFrameworkVersion = string.Empty;
+        }
     }
 }

src/Cli/dotnet/BuildServer/BuildServerProvider.cs

@@ -22,6 +22,11 @@ internal class BuildServerProvider(
 
     public IEnumerable<IBuildServer> EnumerateBuildServers(ServerEnumerationFlags flags = ServerEnumerationFlags.All)
     {
+        if ((flags & ServerEnumerationFlags.Unified) == ServerEnumerationFlags.Unified)
+        {
+            yield return new UnifiedBuildServer();
+        }
+
         if ((flags & ServerEnumerationFlags.MSBuild) == ServerEnumerationFlags.MSBuild)
         {
             // Yield a single MSBuild server (handles server discovery itself)

src/Cli/dotnet/BuildServer/IBuildServer.cs

@@ -11,5 +11,5 @@ internal interface IBuildServer
 
     string Name { get; }
 
-    void Shutdown();
+    Task ShutdownAsync();
 }

src/Cli/dotnet/BuildServer/IBuildServerProvider.cs

@@ -12,7 +12,8 @@ internal enum ServerEnumerationFlags
     MSBuild = 1,
     VBCSCompiler = 2,
     Razor = 4,
-    All = MSBuild | VBCSCompiler | Razor
+    Unified = 5,
+    All = MSBuild | VBCSCompiler | Razor | Unified
 }
 
 internal interface IBuildServerProvider

src/Cli/dotnet/BuildServer/MSBuildServer.cs

@@ -13,8 +13,9 @@ internal class MSBuildServer : IBuildServer
 
     public string Name => CliStrings.MSBuildServer;
 
-    public void Shutdown()
+    public Task ShutdownAsync()
     {
         BuildManager.DefaultBuildManager.ShutdownAllNodes();
+        return Task.CompletedTask;
     }
 }

src/Cli/dotnet/BuildServer/RazorServer.cs

@@ -22,14 +22,15 @@ internal class RazorServer(
 
     public RazorPidFile PidFile { get; } = pidFile ?? throw new ArgumentNullException(nameof(pidFile));
 
-    public void Shutdown()
+    public Task ShutdownAsync()
     {
         if (!_fileSystem.File.Exists(PidFile.ServerPath.Value))
         {
             // The razor server path doesn't exist anymore so trying to shut it down would fail
             // Ensure the pid file is cleaned up so we don't try to shut it down again
             DeletePidFile();
-            return;
+
+            return Task.CompletedTask;
         }
 
         var command = _commandFactory
@@ -57,6 +58,8 @@ public void Shutdown()
         // After a successful shutdown, ensure the pid file is deleted
         // If the pid file was left behind due to a rude exit, this ensures we don't try to shut it down again
         DeletePidFile();
+
+        return Task.CompletedTask;
     }
 
     void DeletePidFile()

src/Cli/dotnet/BuildServer/UnifiedBuildServer.cs

@@ -0,0 +1,33 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Microsoft.DotNet.Cli.Commands;
+using Microsoft.DotNet.Cli.Utils;
+using Microsoft.DotNet.Cli.Utils.Extensions;
+using Microsoft.Net.BuildServerUtils;
+
+namespace Microsoft.DotNet.Cli.BuildServer;
+
+internal sealed class UnifiedBuildServer : IBuildServer
+{
+    public int ProcessId => 0; // Not used
+
+    public string Name => CliCommandStrings.UnifiedBuildServer;
+
+    public Task ShutdownAsync()
+    {
+        var hostServerPath = MSBuildForwardingAppWithoutLogging.GetHostServerPath();
+        Reporter.Output.WriteLine(CliCommandStrings.ShuttingDownUnifiedBuildServers, hostServerPath);
+
+        return BuildServerUtility.ShutdownServersAsync(
+            onProcessShutdownBegin: static (process) =>
+            {
+                Reporter.Error.WriteLine(string.Format(CliCommandStrings.ShuttingDownServerWithPid, process.ProcessName, process.Id).Red());
+            },
+            onError: static (error) =>
+            {
+                Reporter.Error.WriteLine(string.Format(CliCommandStrings.ShutDownFailed, CliCommandStrings.UnifiedBuildServer, error).Red());
+            },
+            hostServerPath: hostServerPath);
+    }
+}

src/Cli/dotnet/BuildServer/VBCSCompilerServer.cs

@@ -10,7 +10,7 @@
 
 namespace Microsoft.DotNet.Cli.BuildServer;
 
-internal class VBCSCompilerServer(ICommandFactory commandFactory = null) : IBuildServer
+internal class VBCSCompilerServer : IBuildServer
 {
     private static readonly string s_toolsetPackageName = "microsoft.net.sdk.compilers.toolset";
     private static readonly string s_vbcsCompilerExeFileName = "VBCSCompiler.exe";
@@ -22,19 +22,14 @@ internal class VBCSCompilerServer(ICommandFactory commandFactory = null) : IBuil
             "bincore",
             "VBCSCompiler.dll");
 
-    private readonly ICommandFactory _commandFactory = commandFactory ?? new DotNetCommandFactory(alwaysRunOutOfProc: true);
-
     public int ProcessId => 0; // Not yet used
 
     public string Name => CliStrings.VBCSCompilerServer;
 
-    public void Shutdown()
+    public Task ShutdownAsync()
     {
         List<string> errors = null;
 
-        // Shutdown the compiler from the SDK.
-        execute(_commandFactory.Create("exec", [VBCSCompilerPath, s_shutdownArg]), ref errors);
-
         // Shutdown toolset compilers.
         Reporter.Verbose.WriteLine($"Shutting down '{s_toolsetPackageName}' compilers.");
         var nuGetPackageRoot = SettingsUtility.GetGlobalPackagesFolder(Settings.LoadDefaultSettings(root: null));
@@ -61,6 +56,8 @@ public void Shutdown()
                     string.Join(Environment.NewLine, errors)));
         }
 
+        return Task.CompletedTask;
+
         static void execute(ICommand command, ref List<string> errors)
         {
             command = command

src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommand.cs

@@ -28,7 +28,8 @@ public BuildServerShutdownCommand(
         bool msbuild = result.GetValue(BuildServerShutdownCommandParser.MSBuildOption);
         bool vbcscompiler = result.GetValue(BuildServerShutdownCommandParser.VbcsOption);
         bool razor = result.GetValue(BuildServerShutdownCommandParser.RazorOption);
-        bool all = !msbuild && !vbcscompiler && !razor;
+        bool unified = result.GetValue(BuildServerShutdownCommandParser.UnifiedOption);
+        bool all = !msbuild && !vbcscompiler && !razor && !unified;
 
         _enumerationFlags = ServerEnumerationFlags.None;
         if (msbuild || all)
@@ -46,6 +47,11 @@ public BuildServerShutdownCommand(
             _enumerationFlags |= ServerEnumerationFlags.Razor;
         }
 
+        if (unified || all)
+        {
+            _enumerationFlags |= ServerEnumerationFlags.Unified;
+        }
+
         _serverProvider = serverProvider ?? new BuildServerProvider();
         _useOrderedWait = useOrderedWait;
         _reporter = reporter ?? Reporter.Output;
@@ -90,7 +96,7 @@ public override int Execute()
         foreach (var server in _serverProvider.EnumerateBuildServers(_enumerationFlags))
         {
             WriteShutdownMessage(server);
-            tasks.Add((server, Task.Run(() => server.Shutdown())));
+            tasks.Add((server, Task.Run(() => server.ShutdownAsync())));
         }
 
         return tasks;

src/Cli/dotnet/Commands/BuildServer/Shutdown/BuildServerShutdownCommandParser.cs

@@ -27,6 +27,12 @@ internal static class BuildServerShutdownCommandParser
         Arity = ArgumentArity.Zero
     };
 
+    public static readonly Option<bool> UnifiedOption = new("--unified")
+    {
+        Description = CliCommandStrings.UnifiedOptionDescription,
+        Arity = ArgumentArity.Zero
+    };
+
     private static readonly Command Command = ConstructCommand();
 
     public static Command GetCommand()
@@ -41,6 +47,7 @@ private static Command ConstructCommand()
         command.Options.Add(MSBuildOption);
         command.Options.Add(VbcsOption);
         command.Options.Add(RazorOption);
+        command.Options.Add(UnifiedOption);
 
         command.SetAction((parseResult) => new BuildServerShutdownCommand(parseResult).Execute());
 

src/Cli/dotnet/Commands/CliCommandStrings.resx

@@ -1863,6 +1863,15 @@ Your project targets multiple frameworks. Specify which framework to run using '
   <data name="ShuttingDownServerWithPid" xml:space="preserve">
     <value>Shutting down {0} (process {1})...</value>
   </data>
+  <data name="ShuttingDownUnifiedBuildServers" xml:space="preserve">
+    <value>Shutting down unified build servers via named pipe ({0})...</value>
+  </data>
+  <data name="UnifiedBuildServer" xml:space="preserve">
+    <value>Unified build server</value>
+  </data>
+  <data name="UnifiedOptionDescription" xml:space="preserve">
+    <value>Shut down unified build servers via named pipes.</value>
+  </data>
   <data name="SkipManifestUpdateOptionDescription" xml:space="preserve">
     <value>Skip updating the workload manifests.</value>
   </data>

src/Cli/dotnet/Commands/Run/VirtualProjectBuildingCommand.cs

@@ -592,11 +592,7 @@ public static string GetArtifactsPath(string entryPointFileFullPath)
     /// </summary>
     public static string GetTempSubdirectory()
     {
-        // We want a location where permissions are expected to be restricted to the current user.
-        string directory = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
-            ? Path.GetTempPath()
-            : Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
-
+        string directory = PathUtility.GetUserRestrictedTempDirectory();
         return Path.Join(directory, "dotnet", "runfile");
     }
 
@@ -614,17 +610,10 @@ public static string GetTempSubpath(string name)
     /// </summary>
     public static void CreateTempSubdirectory(string path)
     {
-        if (OperatingSystem.IsWindows())
-        {
-            Directory.CreateDirectory(path);
-        }
-        else
-        {
-            // Ensure only the current user has access to the directory to avoid leaking the program to other users.
-            // We don't mind that permissions might be different if the directory already exists,
-            // since it's under user's local directory and its path should be unique.
-            Directory.CreateDirectory(path, UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
-        }
+        // Ensure only the current user has access to the directory to avoid leaking the program to other users.
+        // We don't mind that permissions might be different if the directory already exists,
+        // since it's under user's local directory and its path should be unique.
+        PathUtility.CreateUserRestrictedDirectory(path);
     }
 
     public static void WriteProjectFile(