[release/8.0.1xx-preview7] [dotnet][xma] Ensure we don't use DOTNET_R…

…OOT and DOTNET_HOST_PATH in. (#18591)

. the Build Agent and remote tasks

DOTNET_ROOT and DOTNET_HOST_PATH are being deprecated as a mechanism to
store the location of dotnet. PATH will be used instead, so we should
ensure that the existing code that makes usage of these variables is
adapted to the new guidelines. More information:


dotnet/roslyn@f454d69

dotnet/runtime#88754 (comment)

Additionally, to avoid confusion, we are using a dedicate
DOTNET_CUSTOM_PATH variable with the path of the dotnet used by the XMA
Build Agent, so it can be used internally by the tasks without mixing it
with the existing dotnet variables


Backport of #18567

---------

Co-authored-by: Mauro Agnoletti <mauro.agnoletti@gmail.com>
Co-authored-by: GitHub Actions Autoformatter <github-actions-autoformatter@xamarin.com>

msbuild/Messaging/Xamarin.Messaging.Build/TaskRunner.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -10,24 +11,15 @@
 
 namespace Xamarin.Messaging.Build {
 	internal class TaskRunner : ITaskRunner {
-		ITaskSerializer serializer;
-		List<Type> tasks = new List<Type> ();
+		static readonly ITracer tracer = Tracer.Get<TaskRunner> ();
+
+		readonly ITaskSerializer serializer;
+		readonly List<Type> tasks = new List<Type> ();
 
 		internal TaskRunner (ITaskSerializer serializer)
 		{
 			this.serializer = serializer;
-
-			var sdkRootPath = Path.Combine (MessagingContext.GetXmaPath (), "SDKs");
-			var dotnetPath = Path.Combine (sdkRootPath, "dotnet", "dotnet");
-
-			if (File.Exists (dotnetPath)) {
-				Environment.SetEnvironmentVariable ("DOTNET_CUSTOM_HOME", Path.Combine (sdkRootPath, ".home"));
-			} else {
-				//In case the XMA dotnet has not been installed yet
-				dotnetPath = "/usr/local/share/dotnet/dotnet";
-			}
-
-			Environment.SetEnvironmentVariable ("DOTNET_HOST_PATH", dotnetPath);
+			SetDotNetVariables ();
 		}
 
 		internal IEnumerable<Type> Tasks => tasks.AsReadOnly ();
@@ -57,5 +49,68 @@ public ExecuteTaskResult Execute (string taskName, string inputs)
 
 			return result;
 		}
+
+		void SetDotNetVariables ()
+		{
+			var xmaSdkRootPath = Path.Combine (MessagingContext.GetXmaPath (), "SDKs");
+			var xmaDotNetRootPath = Path.Combine (xmaSdkRootPath, "dotnet");
+			var xmaDotNetPath = default (string);
+
+			if (IsValidDotNetInstallation (xmaDotNetRootPath)) {
+				//If the XMA dotnet is already installed, we use it and also declare a custom home for it (for NuGet restore and caches)
+				Environment.SetEnvironmentVariable ("DOTNET_CUSTOM_HOME", Path.Combine (xmaSdkRootPath, ".home"));
+				xmaDotNetPath = GetDotNetPath (xmaDotNetRootPath);
+			} else {
+				//In case the XMA dotnet has not been installed yet, we use the default dotnet installation
+				xmaDotNetPath = GetDefaultDotNetPath ();
+				xmaDotNetRootPath = Path.GetDirectoryName (xmaDotNetPath);
+			}
+
+			var pathContent = GetPathContent ();
+			//We add the XMA dotnet path first so it has priority over the default dotnet installation
+			var newPathContent = $"{xmaDotNetRootPath}:{pathContent}";
+
+			//Override the PATH with the XMA dotnet in it, just in case it's used internally by dotnet
+			Environment.SetEnvironmentVariable ("PATH", newPathContent);
+			//Deprecated dotnet environment variable. We still preserve ir for backwards compatibility with other components that haven't deprecated it yet (like dotnet ILLink)
+			Environment.SetEnvironmentVariable ("DOTNET_HOST_PATH", xmaDotNetPath);
+			//Custom environment variable for internal iOS SDK usage
+			Environment.SetEnvironmentVariable ("DOTNET_CUSTOM_PATH", xmaDotNetPath);
+
+			tracer.Info ($"Using dotnet: {xmaDotNetPath}");
+			tracer.Info ($"Current PATH: {newPathContent}");
+		}
+
+		string GetDefaultDotNetPath ()
+		{
+			var dotnetRootPath = "/usr/local/share/dotnet";
+
+			if (IsValidDotNetInstallation (dotnetRootPath)) {
+				return GetDotNetPath (dotnetRootPath);
+			}
+
+			var dotnetPath = "dotnet";
+			var pathContent = GetPathContent ();
+			var pathElements = pathContent.Split (new string [] { ":" }, StringSplitOptions.RemoveEmptyEntries);
+
+			foreach (var pathElement in pathElements) {
+				try {
+					if (IsValidDotNetInstallation (pathElement)) {
+						dotnetPath = GetDotNetPath (pathElement);
+						break;
+					}
+				} catch {
+					//If we can't read a directory for any reason just skip it
+				}
+			}
+
+			return dotnetPath;
+		}
+
+		string GetPathContent () => Environment.GetEnvironmentVariable ("PATH") ?? "";
+
+		bool IsValidDotNetInstallation (string rootPath) => File.Exists (GetDotNetPath (rootPath));
+
+		string GetDotNetPath (string rootPath) => Path.Combine (rootPath, "dotnet");
 	}
 }

msbuild/Xamarin.MacDev.Tasks/Extensions/TaskExtensions.cs

@@ -5,5 +5,22 @@ namespace Microsoft.Build.Tasks {
 	public static class TaskExtensions {
 		public static bool ShouldExecuteRemotely (this Task task, string sessionId)
 			=> Environment.OSVersion.Platform == PlatformID.Win32NT && !string.IsNullOrEmpty (sessionId);
+
+		public static string GetDotNetPath (this Task task)
+		{
+			//Custom environment variable set by the XMA Build Agent
+			var dotnetPath = Environment.GetEnvironmentVariable ("DOTNET_CUSTOM_PATH");
+
+			if (string.IsNullOrEmpty (dotnetPath)) {
+				//Deprecated dotnet environment variable used for backwards compatibility
+				dotnetPath = Environment.GetEnvironmentVariable ("DOTNET_HOST_PATH");
+			}
+
+			if (string.IsNullOrEmpty (dotnetPath)) {
+				dotnetPath = Environment.OSVersion.Platform == PlatformID.Win32NT ? "dotnet.exe" : "dotnet";
+			}
+
+			return dotnetPath;
+		}
 	}
 }

msbuild/Xamarin.MacDev.Tasks/Tasks/BTouchTaskBase.cs

@@ -8,6 +8,7 @@
 
 using Microsoft.Build.Framework;
 using Microsoft.Build.Utilities;
+using Microsoft.Build.Tasks;
 
 using Xamarin.Utils;
 using Xamarin.Localization.MSBuild;
@@ -75,26 +76,10 @@ public abstract class BTouchTaskBase : XamarinToolTask {
 		[Required]
 		public string ResponseFilePath { get; set; }
 
-		string DotNetPath {
-			get {
-				// Return the dotnet executable we're executing with.
-				var dotnet_path = Environment.GetEnvironmentVariable ("DOTNET_HOST_PATH");
-				if (!string.IsNullOrEmpty (dotnet_path))
-					return dotnet_path;
-
-				if (Environment.OSVersion.Platform == PlatformID.Win32NT) {
-					// This might happen when building from inside VS (design-time builds, etc.)
-					return "dotnet.exe";
-				}
-
-				throw new InvalidOperationException ($"DOTNET_HOST_PATH is not set");
-			}
-		}
-
 		protected override string ToolName {
 			get {
 				if (IsDotNet)
-					return Path.GetFileName (DotNetPath);
+					return Path.GetFileName (this.GetDotNetPath ());
 
 				return Path.GetFileNameWithoutExtension (ToolExe);
 			}
@@ -108,7 +93,7 @@ protected override string GenerateFullPathToTool ()
 			// system dotnet, which might not exist or not have the version we
 			// need.
 			if (IsDotNet)
-				return DotNetPath;
+				return this.GetDotNetPath ();
 
 			return Path.Combine (ToolPath, ToolExe);
 		}

msbuild/Xamarin.MacDev.Tasks/Tasks/ComputeRemoteGeneratorPropertiesTaskBase.cs

@@ -4,6 +4,7 @@
 using System.IO;
 
 using Microsoft.Build.Framework;
+using Microsoft.Build.Tasks;
 
 using Xamarin.Localization.MSBuild;
 using Xamarin.Utils;
@@ -93,9 +94,8 @@ void ComputeProperties ()
 			var environment = default (Dictionary<string, string?>);
 
 			if (IsDotNet) {
-				executable = Environment.GetEnvironmentVariable ("DOTNET_HOST_PATH");
-				if (string.IsNullOrEmpty (executable))
-					executable = "dotnet";
+				executable = this.GetDotNetPath ();
+
 				arguments.Add ("build");
 
 				var customHome = Environment.GetEnvironmentVariable ("DOTNET_CUSTOM_HOME");

msbuild/Xamarin.MacDev.Tasks/Tasks/XamarinBuildTask.cs

@@ -3,6 +3,7 @@
 using System.IO;
 using System.Linq;
 using Microsoft.Build.Framework;
+using Microsoft.Build.Tasks;
 using Xamarin.Localization.MSBuild;
 using Threading = System.Threading.Tasks;
 
@@ -35,12 +36,7 @@ protected string ComputeValueUsingTarget (string computeValueTarget, string targ
 ";
 			File.WriteAllText (projectPath, csproj);
 
-			var dotnetPath = Environment.GetEnvironmentVariable ("DOTNET_HOST_PATH");
-
-			if (string.IsNullOrEmpty (dotnetPath)) {
-				dotnetPath = "dotnet";
-			}
-
+			var dotnetPath = this.GetDotNetPath ();
 			var environment = default (Dictionary<string, string>);
 			var customHome = Environment.GetEnvironmentVariable ("DOTNET_CUSTOM_HOME");