Implement task environment APIs

documentation/specs/multithreading/thread-safe-tasks.md

@@ -109,15 +109,17 @@ To prevent common thread-safety issues related to path handling, we introduce pa
 
 ```csharp
 namespace Microsoft.Build.Framework;
-public readonly struct AbsolutePath
+public readonly struct AbsolutePath : IEquatable<AbsolutePath>
 {
     // Default value returns string.Empty for Path property
-    public string Path { get; }
+    public string Value { get; }
     internal AbsolutePath(string path, bool ignoreRootedCheck) { }
     public AbsolutePath(string path); // Checks Path.IsPathRooted
     public AbsolutePath(string path, AbsolutePath basePath) { }
     public static implicit operator string(AbsolutePath path) { }
-    public override string ToString() => Path;
+    public override string ToString() => Value;
+
+    // overrides for equality and hashcode
 }
 ```
 

src/Build/BackEnd/TaskExecutionHost/MultiProcessTaskEnvironmentDriver.cs

@@ -0,0 +1,77 @@
+// 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.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Internal;
+
+namespace Microsoft.Build.BackEnd
+{
+    /// <summary>
+    /// Default implementation of <see cref="ITaskEnvironmentDriver"/> that directly interacts with the file system
+    /// and environment variables. Used in multi-process mode of execution.
+    /// </summary>
+    /// <remarks>
+    /// Implemented as a singleton since it has no instance state.
+    /// </remarks>
+    internal sealed class MultiProcessTaskEnvironmentDriver : ITaskEnvironmentDriver
+    {
+        /// <summary>
+        /// The singleton instance.
+        /// </summary>
+        private static readonly MultiProcessTaskEnvironmentDriver s_instance = new MultiProcessTaskEnvironmentDriver();
+
+        /// <summary>
+        /// Gets the singleton instance of <see cref="MultiProcessTaskEnvironmentDriver"/>.
+        /// </summary>
+        public static MultiProcessTaskEnvironmentDriver Instance => s_instance;
+
+        private MultiProcessTaskEnvironmentDriver() { }
+
+        /// <inheritdoc/>
+        public AbsolutePath ProjectDirectory
+        {
+            get => new AbsolutePath(Directory.GetCurrentDirectory(), ignoreRootedCheck: true);
+            set => Directory.SetCurrentDirectory(value.Value);
+        }
+
+        /// <inheritdoc/>
+        public AbsolutePath GetAbsolutePath(string path)
+        {
+            return new AbsolutePath(Path.GetFullPath(path), ignoreRootedCheck: true);
+        }
+
+        /// <inheritdoc/>
+        public string? GetEnvironmentVariable(string name)
+        {
+            return Environment.GetEnvironmentVariable(name);
+        }
+
+        /// <inheritdoc/>
+        public IReadOnlyDictionary<string, string> GetEnvironmentVariables()
+        {
+            return CommunicationsUtilities.GetEnvironmentVariables();
+        }
+
+        /// <inheritdoc/>
+        public void SetEnvironmentVariable(string name, string? value)
+        {
+            CommunicationsUtilities.SetEnvironmentVariable(name, value);
+        }
+
+        /// <inheritdoc/>
+        public void SetEnvironment(IDictionary<string, string> newEnvironment)
+        {
+            CommunicationsUtilities.SetEnvironment(newEnvironment);
+        }
+
+        /// <inheritdoc/>
+        public ProcessStartInfo GetProcessStartInfo()
+        {
+            return new ProcessStartInfo();
+        }
+    }
+}

src/Build/BackEnd/TaskExecutionHost/MultiThreadedTaskEnvironmentDriver.cs

@@ -0,0 +1,123 @@
+// 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.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Microsoft.Build.Framework;
+using Microsoft.Build.Internal;
+
+namespace Microsoft.Build.BackEnd
+{
+    /// <summary>
+    /// Implementation of <see cref="ITaskEnvironmentDriver"/> that virtualizes environment variables and current directory
+    /// for use in multithreaded mode where tasks may be executed in parallel. This allows each project to maintain its own
+    /// isolated environment state without affecting other concurrently building projects.
+    /// </summary>
+    /// <remarks>
+    /// This class is not accessed from multiple threads. Each msbuild thread node has its own instance to work with.
+    /// </remarks>
+    internal sealed class MultiThreadedTaskEnvironmentDriver : ITaskEnvironmentDriver
+    {
+        private readonly Dictionary<string, string> _environmentVariables;
+        private AbsolutePath _currentDirectory;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MultiThreadedTaskEnvironmentDriver"/> class
+        /// with the specified working directory and optional environment variables.
+        /// </summary>
+        /// <param name="currentDirectoryFullPath">The initial working directory.</param>
+        /// <param name="environmentVariables">Dictionary of environment variables to use.</param>
+        public MultiThreadedTaskEnvironmentDriver(
+            string currentDirectoryFullPath,
+            IDictionary<string, string> environmentVariables)
+        {
+            _environmentVariables = new Dictionary<string, string>(environmentVariables, CommunicationsUtilities.EnvironmentVariableComparer);
+            _currentDirectory = new AbsolutePath(currentDirectoryFullPath, ignoreRootedCheck: true);
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="MultiThreadedTaskEnvironmentDriver"/> class
+        /// with the specified working directory and environment variables from the current process.
+        /// </summary>
+        /// <param name="currentDirectoryFullPath">The initial working directory.</param>
+        public MultiThreadedTaskEnvironmentDriver(string currentDirectoryFullPath)
+        {
+            IDictionary variables = Environment.GetEnvironmentVariables();
+            _environmentVariables = new Dictionary<string, string>(variables.Count, CommunicationsUtilities.EnvironmentVariableComparer);
+            foreach (DictionaryEntry entry in variables)
+            {
+                _environmentVariables[(string)entry.Key] = (string)entry.Value!;
+            }
+
+            _currentDirectory = new AbsolutePath(currentDirectoryFullPath, ignoreRootedCheck: true);
+        }
+
+        /// <inheritdoc/>
+        public AbsolutePath ProjectDirectory
+        {
+            get => _currentDirectory;
+            set => _currentDirectory = value;
+        }
+
+        /// <inheritdoc/>
+        public AbsolutePath GetAbsolutePath(string path)
+        {
+            return new AbsolutePath(path, ProjectDirectory);
+        }
+
+        /// <inheritdoc/>
+        public string? GetEnvironmentVariable(string name)
+        {
+            return _environmentVariables.TryGetValue(name, out string? value) ? value : null;
+        }
+
+        /// <inheritdoc/>
+        public IReadOnlyDictionary<string, string> GetEnvironmentVariables()
+        {
+            return _environmentVariables;
+        }
+
+        /// <inheritdoc/>
+        public void SetEnvironmentVariable(string name, string? value)
+        {
+            if (value == null)
+            {
+                _environmentVariables.Remove(name);
+            }
+            else
+            {
+                _environmentVariables[name] = value;
+            }
+        }
+
+        /// <inheritdoc/>
+        public void SetEnvironment(IDictionary<string, string> newEnvironment)
+        {
+            // Simply replace the entire environment dictionary
+            _environmentVariables.Clear();
+            foreach (KeyValuePair<string, string> entry in newEnvironment)
+            {
+                _environmentVariables[entry.Key] = entry.Value;
+            }
+        }
+
+        /// <inheritdoc/>
+        public ProcessStartInfo GetProcessStartInfo()
+        {
+            var startInfo = new ProcessStartInfo
+            {
+                WorkingDirectory = ProjectDirectory.Value
+            };
+
+            // Set environment variables
+            foreach (var kvp in _environmentVariables)
+            {
+                startInfo.EnvironmentVariables[kvp.Key] = kvp.Value;
+            }
+
+            return startInfo;
+        }
+    }
+}

src/Build/Microsoft.Build.csproj

@@ -374,6 +374,8 @@
     <Compile Include="BackEnd\Node\INode.cs" />
     <!-- ########################## -->
     <Compile Include="BackEnd\TaskExecutionHost\TaskExecutionHost.cs" />
+    <Compile Include="BackEnd\TaskExecutionHost\MultiProcessTaskEnvironmentDriver.cs" />
+    <Compile Include="BackEnd\TaskExecutionHost\MultiThreadedTaskEnvironmentDriver.cs" />
     <!-- #### COLLECTIONS ### -->
     <Compile Include="..\Shared\CollectionHelpers.cs" />
     <Compile Include="Collections\ArrayDictionary.cs" />