GetReferenceAssemblyPaths.cs

// 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 Microsoft.Build.Framework;
using Microsoft.Build.Shared;
using Microsoft.Build.Utilities;
using FrameworkNameVersioning = System.Runtime.Versioning.FrameworkName;

#if FEATURE_GAC
using System.Threading;
using SystemProcessorArchitecture = System.Reflection.ProcessorArchitecture;
#endif

#nullable disable

namespace Microsoft.Build.Tasks
{
    /// <summary>
    /// Returns the reference assembly paths to the various frameworks
    /// </summary>
    [MSBuildMultiThreadableTask]
    public class GetReferenceAssemblyPaths : TaskExtension, IMultiThreadableTask
    {
        /// <inheritdoc />
        public TaskEnvironment TaskEnvironment { get; set; } = TaskEnvironment.Fallback;

        #region Data
#if FEATURE_GAC
        /// <summary>
        /// This is the sentinel assembly for .NET FX 3.5 SP1
        /// Used to determine if SP1 of 3.5 is installed
        /// </summary>
        private const string NET35SP1SentinelAssemblyName = "System.Data.Entity, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089, processorArchitecture=MSIL";

        /// <summary>
        /// Cache in a static whether or not we have found the 35sp1sentinel assembly.
        /// </summary>
        private static readonly Lazy<bool> s_net35SP1SentinelAssemblyFound = new Lazy<bool>(() =>
        {
            // get an assemblyname from the string representation of the sentinel assembly name
            var sentinelAssemblyName = new AssemblyNameExtension(NET35SP1SentinelAssemblyName);
            string path = GlobalAssemblyCache.GetLocation(
                sentinelAssemblyName,
                SystemProcessorArchitecture.MSIL,
                runtimeVersion => "v2.0.50727",
                new Version("2.0.57027"),
                false,
                new FileExists(p => FileUtilities.FileExistsNoThrow(p)),
                GlobalAssemblyCache.pathFromFusionName,
                GlobalAssemblyCache.gacEnumerator,
                false);

            return !string.IsNullOrEmpty(path);
        }, LazyThreadSafetyMode.PublicationOnly);
#endif

        /// <summary>
        /// Hold the reference assembly paths based on the passed in targetframeworkmoniker.
        /// </summary>
        private IList<string> _tfmPaths;

        /// <summary>
        /// Hold the reference assembly paths based on the passed in targetframeworkmoniker without considering any profile passed in.
        /// </summary>
        private IList<string> _tfmPathsNoProfile;

        #endregion

        #region Properties

        /// <summary>
        /// Returns the path based on the passed in TargetFrameworkMoniker. If the TargetFrameworkMoniker is null or empty
        /// this path will be empty.
        /// </summary>
        [Output]
        public string[] ReferenceAssemblyPaths
        {
            get
            {
                if (_tfmPaths != null)
                {
                    var pathsToReturn = new string[_tfmPaths.Count];
                    _tfmPaths.CopyTo(pathsToReturn, 0);
                    return pathsToReturn;
                }
                else
                {
                    return [];
                }
            }
        }

        /// <summary>
        /// Returns the path based on the passed in TargetFrameworkMoniker without considering the profile part of the moniker. If the TargetFrameworkMoniker is null or empty
        /// this path will be empty.
        /// </summary>
        [Output]
        public string[] FullFrameworkReferenceAssemblyPaths
        {
            get
            {
                if (_tfmPathsNoProfile != null)
                {
                    string[] pathsToReturn = new string[_tfmPathsNoProfile.Count];
                    _tfmPathsNoProfile.CopyTo(pathsToReturn, 0);
                    return pathsToReturn;
                }
                else
                {
                    return [];
                }
            }
        }

        /// <summary>
        /// The target framework moniker to get the reference assembly paths for
        /// </summary>
        public string TargetFrameworkMoniker { get; set; }

        /// <summary>
        /// The root path to use to generate the reference assembly path
        /// </summary>
        public string RootPath { get; set; }

        /// <summary>
        /// By default GetReferenceAssemblyPaths performs simple checks
        /// to ensure that certain runtime frameworks are installed depending on the
        /// target framework.
        /// set BypassFrameworkInstallChecks to true in order to bypass those checks.
        /// </summary>
        public bool BypassFrameworkInstallChecks { get; set; }

        /// <summary>
        /// If set to true, the task will not generate an error (or a warning) if the reference assemblies cannot be found.
        /// This allows the task to be used to check whether reference assemblies for a framework are available.
        /// </summary>
        public bool SuppressNotFoundError { get; set; }

        /// <summary>
        /// Gets the display name for the targetframeworkmoniker
        /// </summary>
        [Output]
        public string TargetFrameworkMonikerDisplayName { get; set; }

        /// <summary>
        /// Target frameworks are looked up in @RootPath. If it cannot be found
        /// there, then paths in @TargetFrameworkFallbackSearchPaths
        /// are used for the lookup, in order. This can have multiple paths, separated
        /// by ';'
        /// </summary>
        public string TargetFrameworkFallbackSearchPaths
        {
            get;
            set;
        }

        #endregion

        #region ITask Members

        /// <summary>
        /// If the target framework moniker is set, generate the correct Paths.
        /// </summary>
        public override bool Execute()
        {
            AbsolutePath? absoluteRootPath = !string.IsNullOrEmpty(RootPath)
                ? TaskEnvironment.GetAbsolutePath(RootPath)
                : new AbsolutePath(RootPath, ignoreRootedCheck: true);
            IList<AbsolutePath> absoluteFallbackSearchPaths = ResolveAbsoluteFallbackSearchPaths(TargetFrameworkFallbackSearchPaths);

            FrameworkNameVersioning moniker;
            FrameworkNameVersioning monikerWithNoProfile = null;

            // Are we targeting a profile.
            bool targetingProfile;

            try
            {
                moniker = new FrameworkNameVersioning(TargetFrameworkMoniker);
                targetingProfile = !String.IsNullOrEmpty(moniker.Profile);

                // If we are targeting a profile we need to generate a set of reference assembly paths which describe where the full framework
                //  exists, to do so we need to get the reference assembly location without the profile as part of the moniker.
                if (targetingProfile)
                {
                    monikerWithNoProfile = new FrameworkNameVersioning(moniker.Identifier, moniker.Version);
                }

#if FEATURE_GAC
                // This is a very specific "hack" to ensure that when we're targeting certain .NET Framework versions that
                // WPF gets to rely on .NET FX 3.5 SP1 being installed on the build machine.
                // This only needs to occur when we are targeting a .NET FX prior to v4.0
                if (!BypassFrameworkInstallChecks && moniker.Identifier.Equals(".NETFramework", StringComparison.OrdinalIgnoreCase) &&
                    moniker.Version.Major < 4)
                {
                    // We did not find the SP1 sentinel assembly in the GAC. Therefore we must assume that SP1 isn't installed
                    if (!s_net35SP1SentinelAssemblyFound.Value)
                    {
                        Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.NETFX35SP1NotIntstalled", TargetFrameworkMoniker);
                    }
                }
#endif
            }
            catch (ArgumentException e)
            {
                Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.InvalidTargetFrameworkMoniker", TargetFrameworkMoniker, e.Message);
                return false;
            }

            try
            {
                _tfmPaths = GetPaths(absoluteRootPath, absoluteFallbackSearchPaths, moniker);

                if (_tfmPaths?.Count > 0)
                {
                    TargetFrameworkMonikerDisplayName = ToolLocationHelper.GetDisplayNameForTargetFrameworkDirectory(_tfmPaths[0], moniker);
                }

                // If there is a profile get the paths without the profile.
                // There is no point in generating the full framework paths if profile path could not be found.
                if (targetingProfile && _tfmPaths != null)
                {
                    _tfmPathsNoProfile = GetPaths(absoluteRootPath, absoluteFallbackSearchPaths, monikerWithNoProfile);
                }

                // The path with out the profile is just the reference assembly paths.
                if (!targetingProfile)
                {
                    _tfmPathsNoProfile = _tfmPaths;
                }
            }
            catch (Exception e)
            {
                // The reason we need to do exception E here is because we are in a task and have the ability to log the message and give the user
                // feedback as to its cause, tasks if at all possible should not have exception leave them.
                Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.ProblemGeneratingReferencePaths", TargetFrameworkMoniker, e.Message);

                if (ExceptionHandling.IsCriticalException(e))
                {
                    throw;
                }

                _tfmPathsNoProfile = null;
                TargetFrameworkMonikerDisplayName = null;
            }

            return !Log.HasLoggedErrors;
        }

        /// <summary>
        /// Generate the set of chained reference assembly paths
        /// </summary>
        private IList<String> GetPaths(AbsolutePath? rootPath, IList<AbsolutePath> fallbackSearchPaths, FrameworkNameVersioning frameworkmoniker)
        {
            string fallbackSearchPathsJoined = fallbackSearchPaths.Count > 0
                ? string.Join(";", fallbackSearchPaths)
                : null;

            IList<String> pathsToReturn = ToolLocationHelper.GetPathToReferenceAssemblies(
                                                frameworkmoniker.Identifier,
                                                frameworkmoniker.Version.ToString(),
                                                frameworkmoniker.Profile,
                                                rootPath?.Value,
                                                fallbackSearchPathsJoined);

            if (!SuppressNotFoundError)
            {
                // No reference assembly paths could be found, log an error so an invalid build will not be produced.
                // 1/26/16: Note this was changed from a warning to an error (see GitHub #173).
                if (pathsToReturn.Count == 0)
                {
                    // Fixes bad error message when an old SDK assumes "net50" means ".NETFramework 5.0" instead of "netcoreapp 5.0"
                    // https://github.com/dotnet/msbuild/issues/5820
                    if (frameworkmoniker.Identifier == ".NETFramework" && frameworkmoniker.Version.Major >= 5)
                    {
                        Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.OutOfDateSDK", frameworkmoniker.ToString());
                    }
                    else
                    {
                        Log.LogErrorWithCodeFromResources("GetReferenceAssemblyPaths.NoReferenceAssemblyDirectoryFound", frameworkmoniker.ToString());
                    }
                }
            }

            return pathsToReturn;
        }

        /// <summary>
        /// Resolves each semicolon-separated fallback search path to absolute via TaskEnvironment.
        /// </summary>
        private IList<AbsolutePath> ResolveAbsoluteFallbackSearchPaths(string fallbackSearchPaths)
        {
            if (string.IsNullOrEmpty(fallbackSearchPaths))
            {
                return [];
            }

            string[] parts = fallbackSearchPaths.Split(MSBuildConstants.SemicolonChar, StringSplitOptions.RemoveEmptyEntries);
            var result = new AbsolutePath[parts.Length];
            for (int i = 0; i < parts.Length; i++)
            {
                result[i] = TaskEnvironment.GetAbsolutePath(parts[i]);
            }

            return result;
        }

        #endregion
    }
}