public override SdkResult Resolve(
SdkReference sdkReference,
SdkResolverContext resolverContext,
SdkResultFactory factory)
{
string sdkDescription = sdkReference.Name;
if (!string.IsNullOrEmpty(sdkReference.Version))
{
sdkDescription += $" {sdkReference.Version}";
}
if (!string.IsNullOrEmpty(sdkReference.MinimumVersion))
{
sdkDescription += $" (>= {sdkReference.MinimumVersion})";
}
var unresolvableReasons = new List <string>();
string dir = Environment.GetEnvironmentVariable("RESOLVE_REPO_TOOLSET_SDK_DIR");
if (string.IsNullOrEmpty(dir))
{
unresolvableReasons.Add("No 'RESOLVE_REPO_TOOLSET_SDK_DIR' passed.");
}
string version = Environment.GetEnvironmentVariable("RESOLVE_REPO_TOOLSET_SDK_VERSION");
if (string.IsNullOrEmpty(version))
{
unresolvableReasons.Add("No 'RESOLVE_REPO_TOOLSET_SDK_VERSION' passed.");
}
if (!sdkReference.Name.Equals("RoslynTools.RepoToolset", StringComparison.OrdinalIgnoreCase))
{
unresolvableReasons.Add($"Sdk isn't RoslynTools.RepoToolset: {sdkDescription}");
}
if (unresolvableReasons.Any())
{
return(factory.IndicateFailure(unresolvableReasons.Select(r => $"{r} ({Name})")));
}
resolverContext.Logger.LogMessage(
$"Overriding {sdkDescription} to '{version}' at '{dir}'",
MessageImportance.High);
return(factory.IndicateSuccess(dir, version));
}
public override SdkResult Resolve(SdkReference sdk, SdkResolverContext resolverContext, SdkResultFactory factory)
{
resolverContext.Logger.LogMessage("MockSdkResolverThrows running", MessageImportance.Normal);
throw new ArithmeticException("EXMESSAGE");
}
public override SdkResult Resolve(SdkReference sdk, SdkResolverContext resolverContext, SdkResultFactory factory)
{
resolverContext.Logger.LogMessage("MockSdkResolver2 running", MessageImportance.Normal);
if (sdk.Name.StartsWith("2"))
{
return(factory.IndicateSuccess("resolverpath2", "version2", new[] { "WARNING2" }));
}
return(factory.IndicateFailure(new[] { "ERROR2" }, new[] { "WARNING2" }));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext, SdkResultFactory factory)
{
SdkVersion.TryParse(sdkReference.MinimumVersion, out SdkVersion minVersion);
SdkInfo bestSdk = null;
// Pick the SDK with the highest version
foreach (var sdk in sdkFetcher())
{
if (StringComparer.OrdinalIgnoreCase.Equals(sdk.Name, sdkReference.Name))
{
if (sdk.Version != null)
{
// If the sdk has a version, it must satisfy the min version requirement
if (minVersion != null && sdk.Version < minVersion)
{
continue;
}
if (bestSdk?.Version == null || bestSdk.Version < sdk.Version)
{
bestSdk = sdk;
}
}
else
{
// Pick this sdk for now, even if it has no version info
if (bestSdk == null)
{
bestSdk = sdk;
}
}
}
}
if (bestSdk != null)
{
return(factory.IndicateSuccess(bestSdk.Path, bestSdk.Version?.ToString()));
}
else
{
return(factory.IndicateFailure(new string [] { "SDK not found" }));
}
}
/// <summary>
/// Resolves the specified SDK reference.
/// </summary>
/// <param name="sdkReference">A <see cref="SdkReference" /> containing the referenced SDKs be resolved.</param>
/// <param name="resolverContext">Context for resolving the SDK.</param>
/// <param name="factory">Factory class to create an <see cref="SdkResult" /></param>
/// <returns>
/// An <see cref="SdkResult" /> containing the resolved SDKs or associated error / reason
/// the SDK could not be resolved. Return <code>null</code> if the resolver is not
/// applicable for a particular <see cref="SdkReference"/>.
/// </returns>
/// <remarks>
/// Note: You must use <see cref="Microsoft.Build.Framework.SdkResultFactory"/> to return a result.
/// </remarks>
///
public abstract SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext,
SdkResultFactory factory);
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext, SdkResultFactory factory)
{
if (sdkReference.Name != "Mono.UE4.Sdk")
{
return(factory.IndicateFailure(new[] { $"Not a UE4 SDK reference" }));
}
//provide a way to force a specific directory
string engineDir = Environment.GetEnvironmentVariable("MONOUE_SDKRESOLVER_OVERRIDE_ENGINE_DIR");
if (string.IsNullOrEmpty(engineDir))
{
var uproject = GetUProjectFromMSBuildProject(resolverContext.SolutionFilePath, resolverContext.ProjectFilePath);
if (uproject == null)
{
return(factory.IndicateFailureAndLog(new[] { $"Could not find a uproject file" }));
}
var engineAssociation = ReadEngineAssociationFromUProject(uproject);
engineDir = GetEngineFromID(engineAssociation);
if (string.IsNullOrEmpty(engineDir))
{
string installedLocationsInfo = ". Found: " + string.Join(", ", EnumerateEngineInstallations().ToList().Select(x => x.ID));
return(factory.IndicateFailureAndLog(new[] { $"Could not find UE4 engine matching '{engineAssociation}' {installedLocationsInfo}" }));
}
}
if (!Directory.Exists(engineDir))
{
return(factory.IndicateFailureAndLog(new[] { $"UE4 engine directory '{engineDir}' does not exist" }));
}
if (!IsValidEngineDirectory(engineDir))
{
return(factory.IndicateFailureAndLog(new[] { $"Engine '{engineDir}' is not a valid installation" }));
}
if (!IsMonoUEEngineDirectory(engineDir))
{
return(factory.IndicateFailureAndLog(new[] { $"Engine '{engineDir}' does not contain MonoUE plugin" }));
}
var sdkDir = Path.Combine(engineDir, "Engine", "Plugins", "MonoUE", "MSBuild", "Sdks", sdkReference.Name, "Sdk");
if (Directory.Exists(sdkDir))
{
string engineVersion = GetEngineVersion(engineDir);
return(factory.IndicateSuccess(sdkDir, "1.0"));
}
return(factory.IndicateFailureAndLog(new[] { $"Did not find SDK '{sdkReference.Name}'" }));
}
private static SdkResult Failure(SdkResultFactory factory, string format, params object[] args)
{
return(factory.IndicateFailure(new[] { string.Format(format, args) }));
}
/// <summary>Resolves the specified SDK reference from NuGet.</summary>
/// <param name="sdkReference">A <see cref="T:Microsoft.Build.Framework.SdkReference" /> containing the referenced SDKs be resolved.</param>
/// <param name="resolverContext">Context for resolving the SDK.</param>
/// <param name="factory">Factory class to create an <see cref="T:Microsoft.Build.Framework.SdkResult" /></param>
/// <returns>
/// An <see cref="T:Microsoft.Build.Framework.SdkResult" /> containing the resolved SDKs or associated error / reason
/// the SDK could not be resolved. Return <code>null</code> if the resolver is not
/// applicable for a particular <see cref="T:Microsoft.Build.Framework.SdkReference" />.
/// </returns>
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext, SdkResultFactory factory)
{
// Escape hatch to disable this resolver
if (DisableNuGetSdkResolver.Value)
{
return(null);
}
// This resolver only works if the user specifies a version in a project or a global.json.
// Ignore invalid versions, there may be another resolver that can handle the version specified
if (!TryGetNuGetVersionForSdk(sdkReference.Name, sdkReference.Version, resolverContext, out var parsedSdkVersion))
{
return(null);
}
return(NuGetAbstraction.GetSdkResult(sdkReference, parsedSdkVersion, resolverContext, factory));
}
public static SdkResult GetSdkResult(SdkReference sdk, object nuGetVersion, SdkResolverContext context, SdkResultFactory factory)
{
// Cast the NuGet version since the caller does not want to consume NuGet classes directly
var parsedSdkVersion = (NuGetVersion)nuGetVersion;
// Stores errors and warnings for the result
ICollection <string> errors = new List <string>();
ICollection <string> warnings = new List <string>();
// Load NuGet settings and a path resolver
var settings = Settings.LoadDefaultSettings(context.ProjectFilePath);
var fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
var libraryIdentity = new LibraryIdentity(sdk.Name, parsedSdkVersion, LibraryType.Package);
// Attempt to find a package if its already installed
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, libraryIdentity, out var installedPath, out var installedVersion))
{
try
{
var nugetSDKLogger = new NuGetSdkLogger(context.Logger, warnings, errors);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(nugetSDKLogger, nonInteractive: context.IsNonInteractive());
// Asynchronously run the restore without a commit which find the package on configured feeds, download, and unzip it without generating any other files
// This must be run in its own task because legacy project system evaluates projects on the UI thread which can cause RunWithoutCommit() to deadlock
// https://developercommunity.visualstudio.com/content/problem/311379/solution-load-never-completes-when-project-contain.html
var restoreTask = Task.Run(() => RestoreRunnerEx.RunWithoutCommit(
libraryIdentity,
settings,
nugetSDKLogger));
var results = restoreTask.Result;
fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
// Look for a successful result, any errors are logged by NuGet
foreach (var result in results.Select(i => i.Result).Where(i => i.Success))
{
// Find the information about the package that was installed. In some cases, the version can be different than what was specified (like you specify 1.0 but get 1.0.0)
var installedPackage = result.GetAllInstalled().FirstOrDefault(i => i == libraryIdentity);
if (installedPackage != null)
{
if (TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, installedPackage, out installedPath, out installedVersion))
{
break;
}
// This should never happen because we were told the package was successfully installed.
// If we can't find it, we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.CouldNotFindInstalledPackage, sdk));
}
else
{
// This should never happen because we were told the restore succeeded.
// If we can't find the package from GetAllInstalled(), we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.PackageWasNotInstalled, sdk, sdk.Name));
}
}
}
catch (Exception e)
{
errors.Add(e.Message);
}
finally
{
// The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger.
DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance);
}
}
if (errors.Count == 0)
{
return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: warnings));
}
return(factory.IndicateFailure(errors, warnings));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext, SdkResultFactory factory)
{
if (!_enabled)
{
return(null);
}
InitializeWorkloadResolver(resolverContext);
if (sdkReference.Name.Equals("Microsoft.NET.SDK.WorkloadAutoImportPropsLocator", StringComparison.OrdinalIgnoreCase))
{
List <string> autoImportSdkPaths = new List <string>();
foreach (var sdkPackInfo in _workloadResolver.GetInstalledWorkloadPacksOfKind(WorkloadPackKind.Sdk))
{
string sdkPackSdkFolder = Path.Combine(sdkPackInfo.Path, "Sdk");
string autoImportPath = Path.Combine(sdkPackSdkFolder, "AutoImport.props");
if (File.Exists(autoImportPath))
{
autoImportSdkPaths.Add(sdkPackSdkFolder);
}
}
// Call Distinct() here because with aliased packs, there may be duplicates of the same path
return(factory.IndicateSuccess(autoImportSdkPaths.Distinct(), sdkReference.Version));
}
else if (sdkReference.Name.Equals("Microsoft.NET.SDK.WorkloadManifestTargetsLocator", StringComparison.OrdinalIgnoreCase))
{
List <string> workloadManifestPaths = new List <string>();
foreach (var manifestDirectory in _workloadManifestProvider.GetManifestDirectories())
{
var workloadManifestTargetPath = Path.Combine(manifestDirectory, "WorkloadManifest.targets");
if (File.Exists(workloadManifestTargetPath))
{
workloadManifestPaths.Add(manifestDirectory);
}
}
return(factory.IndicateSuccess(workloadManifestPaths, sdkReference.Version));
}
else
{
var packInfo = _workloadResolver.TryGetPackInfo(sdkReference.Name);
if (packInfo != null)
{
if (Directory.Exists(packInfo.Path))
{
return(factory.IndicateSuccess(Path.Combine(packInfo.Path, "Sdk"), sdkReference.Version));
}
else
{
var itemsToAdd = new Dictionary <string, SdkResultItem>();
itemsToAdd.Add("MissingWorkloadPack",
new SdkResultItem(sdkReference.Name,
metadata: new Dictionary <string, string>()
{
{ "Version", packInfo.Version }
}));
Dictionary <string, string> propertiesToAdd = new Dictionary <string, string>();
return(factory.IndicateSuccess(Enumerable.Empty <string>(),
sdkReference.Version,
propertiesToAdd: propertiesToAdd,
itemsToAdd: itemsToAdd));
}
}
}
return(null);
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext context, SdkResultFactory factory)
{
string msbuildSdksDir = null;
string netcoreSdkVersion = null;
if (context.State is CachedResult priorResult)
{
msbuildSdksDir = priorResult.MSBuildSdksDir;
netcoreSdkVersion = priorResult.NETCoreSdkVersion;
}
if (msbuildSdksDir == null)
{
// These are overrides that are used to force the resolved SDK tasks and targets to come from a given
// base directory and report a given version to msbuild (which may be null if unknown. One key use case
// for this is to test SDK tasks and targets without deploying them inside the .NET Core SDK.
msbuildSdksDir = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_DIR");
netcoreSdkVersion = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_VER");
}
if (msbuildSdksDir == null)
{
string dotnetExeDir = GetDotnetExeDirectory();
var resolverResult = ResolveNETCoreSdkDirectory(context, dotnetExeDir);
string netcoreSdkDir = resolverResult.ResolvedSdkDirectory;
string globalJsonPath = resolverResult.GlobalJsonPath;
if (netcoreSdkDir == null)
{
return(Failure(
factory,
Strings.UnableToLocateNETCoreSdk));
}
msbuildSdksDir = Path.Combine(netcoreSdkDir, "Sdks");
netcoreSdkVersion = new DirectoryInfo(netcoreSdkDir).Name;
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, sdkReference.MinimumVersion))
{
return(Failure(
factory,
Strings.NETCoreSDKSmallerThanMinimumRequestedVersion,
netcoreSdkVersion,
sdkReference.MinimumVersion));
}
Version minimumMSBuildVersion = GetMinimumMSBuildVersion(netcoreSdkDir);
if (context.MSBuildVersion < minimumMSBuildVersion)
{
return(Failure(
factory,
Strings.MSBuildSmallerThanMinimumVersion,
netcoreSdkVersion,
minimumMSBuildVersion,
context.MSBuildVersion));
}
string minimumVSDefinedSDKVersion = GetMinimumVSDefinedSDKVersion();
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, minimumVSDefinedSDKVersion))
{
return(Failure(
factory,
Strings.NETCoreSDKSmallerThanMinimumVersionRequiredByVisualStudio,
netcoreSdkVersion,
minimumVSDefinedSDKVersion));
}
}
context.State = new CachedResult
{
MSBuildSdksDir = msbuildSdksDir,
NETCoreSdkVersion = netcoreSdkVersion
};
string msbuildSdkDir = Path.Combine(msbuildSdksDir, sdkReference.Name, "Sdk");
if (!Directory.Exists(msbuildSdkDir))
{
return(Failure(
factory,
Strings.MSBuildSDKDirectoryNotFound,
msbuildSdkDir));
}
return(factory.IndicateSuccess(msbuildSdkDir, netcoreSdkVersion));
}
public override SdkResult Resolve(SdkReference sdk, SdkResolverContext context, SdkResultFactory factory)
{
var sdkPath = Path.Combine(BuildEnvironmentHelper.Instance.MSBuildSDKsPath, sdk.Name, "Sdk");
// Note: On failure MSBuild will log a generic message, no need to indicate a failure reason here.
return(FileUtilities.DirectoryExistsNoThrow(sdkPath)
? factory.IndicateSuccess(sdkPath, string.Empty)
: factory.IndicateFailure(null));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext, SdkResultFactory factory)
{
var sdksPath = MSBuildProjectService.GetDefaultSdksPath(TargetRuntime);
var sdkPath = Path.Combine(sdksPath, sdkReference.Name, "Sdk");
// Note: On failure MSBuild will log a generic message, no need to indicate a failure reason here.
return(System.IO.Directory.Exists(sdkPath)
? factory.IndicateSuccess(sdkPath, string.Empty)
: factory.IndicateFailure(null));
}
public override SdkResult Resolve(
SdkReference sdkReference,
SdkResolverContext resolverContext,
SdkResultFactory factory)
{
string sdkDescription = sdkReference.Name;
if (!string.IsNullOrEmpty(sdkReference.Version))
{
sdkDescription += $" {sdkReference.Version}";
}
if (!string.IsNullOrEmpty(sdkReference.MinimumVersion))
{
sdkDescription += $" (>= {sdkReference.MinimumVersion})";
}
SourceBuiltSdkOverride[] overrides = Environment.GetEnvironmentVariables()
.Cast <DictionaryEntry>()
.Select(SourceBuiltSdkOverride.Create)
.Where(o => o != null)
.ToArray();
void LogMessage(string message)
{
resolverContext.Logger.LogMessage($"[{Name}] {message}", MessageImportance.High);
}
if (overrides.Any())
{
string separator = overrides.Length == 1 ? " " : Environment.NewLine;
LogMessage(
$"Looking for SDK {sdkDescription}. Detected config(s) in env:{separator}" +
string.Join(Environment.NewLine, overrides.Select(o => o.ToString())));
}
SourceBuiltSdkOverride[] matches = overrides
.Where(o => sdkReference.Name.Equals(o?.Id, StringComparison.OrdinalIgnoreCase))
.ToArray();
var unresolvableReasons = new List <string>();
if (matches.Length != 1)
{
unresolvableReasons.Add(
$"{matches.Length} overrides found for '{sdkReference.Name}'");
}
else
{
SourceBuiltSdkOverride match = matches[0];
string[] matchProblems = match.GetValidationErrors().ToArray();
if (matchProblems.Any())
{
unresolvableReasons.Add($"Found match '{match.Group}' with problems:");
unresolvableReasons.AddRange(matchProblems);
}
else
{
LogMessage($"Overriding {sdkDescription} with '{match.Group}'");
return(factory.IndicateSuccess(match.SdkDir, match.Version));
}
}
return(factory.IndicateFailure(unresolvableReasons.Select(r => $"[{Name}] {r}")));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext, SdkResultFactory factory) => null;
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext context, SdkResultFactory factory)
{
// These are overrides that are used to force the resolved SDK tasks and targets to come from a given
// base directory and report a given version to msbuild (which may be null if unknown. One key use case
// for this is to test SDK tasks and targets without deploying them inside the .NET Core SDK.
string msbuildSdksDir = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_DIR");
string netcoreSdkVersion = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_VER");
if (msbuildSdksDir == null)
{
string netcoreSdkDir = ResolveNetcoreSdkDirectory(context);
if (netcoreSdkDir == null)
{
return(factory.IndicateFailure(
new[]
{
"Unable to locate the .NET Core SDK. Check that it is installed and that the version"
+ " specified in global.json (if any) matches the installed version."
}));
}
msbuildSdksDir = Path.Combine(netcoreSdkDir, "Sdks");
netcoreSdkVersion = new DirectoryInfo(netcoreSdkDir).Name;;
}
string msbuildSdkDir = Path.Combine(msbuildSdksDir, sdkReference.Name, "Sdk");
if (!Directory.Exists(msbuildSdkDir))
{
return(factory.IndicateFailure(
new[]
{
$"{msbuildSdkDir} not found. Check that a recent enough .NET Core SDK is installed"
+ " and/or increase the version specified in global.json. "
}));
}
return(factory.IndicateSuccess(msbuildSdkDir, netcoreSdkVersion));
}
public static SdkResult GetSdkResult(SdkReference sdk, object nuGetVersion, SdkResolverContext context, SdkResultFactory factory)
{
// Cast the NuGet version since the caller does not want to consume NuGet classes directly
var parsedSdkVersion = (NuGetVersion)nuGetVersion;
// Stores errors and warnings for the result
ICollection <string> errors = new List <string>();
ICollection <string> warnings = new List <string>();
// Load NuGet settings and a path resolver
var settings = Settings.LoadDefaultSettings(context.ProjectFilePath);
var fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
// Attempt to find a package if its already installed
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, sdk.Name, parsedSdkVersion, out var installedPath, out var installedVersion))
{
try
{
// Asynchronously run the restore without a commit which find the package on configured feeds, download, and unzip it without generating any other files
var results = RestoreRunnerEx.RunWithoutCommit(
context.ProjectFilePath,
sdk.Name,
parsedSdkVersion.ToFullString(),
settings,
new NuGetSdkLogger(context.Logger, warnings, errors))
.ConfigureAwait(continueOnCapturedContext: false)
.GetAwaiter()
.GetResult();
fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
// Look for a successful result, any errors are logged by NuGet
foreach (var result in results.Select(i => i.Result).Where(i => i.Success))
{
// Find the information about the package that was installed. In some cases, the version can be different than what was specified (like you specify 1.0 but get 1.0.0)
var installedPackage = result.GetAllInstalled().FirstOrDefault(i => i.Name.Equals(sdk.Name));
if (installedPackage != null)
{
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, installedPackage.Name, installedPackage.Version, out installedPath, out installedVersion))
{
// This should never happen because we were told the package was successfully installed.
// If we can't find it, we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.CouldNotFindInstalledPackage, sdk));
}
}
else
{
// This should never happen because we were told the restore succeeded.
// If we can't find the package from GetAllInstalled(), we probably did something wrong with the NuGet API
errors.Add(string.Format(CultureInfo.CurrentCulture, Strings.PackageWasNotInstalled, sdk, sdk.Name));
}
}
}
catch (Exception e)
{
errors.Add(e.Message);
}
}
if (errors.Count == 0)
{
return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: warnings));
}
return(factory.IndicateFailure(errors, warnings));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext context, SdkResultFactory factory)
{
string msbuildSdksDir = null;
string netcoreSdkVersion = null;
IDictionary <string, string> propertiesToAdd = null;
IDictionary <string, SdkResultItem> itemsToAdd = null;
List <string> warnings = null;
if (context.State is CachedResult priorResult)
{
msbuildSdksDir = priorResult.MSBuildSdksDir;
netcoreSdkVersion = priorResult.NETCoreSdkVersion;
}
if (msbuildSdksDir == null)
{
// These are overrides that are used to force the resolved SDK tasks and targets to come from a given
// base directory and report a given version to msbuild (which may be null if unknown. One key use case
// for this is to test SDK tasks and targets without deploying them inside the .NET Core SDK.
msbuildSdksDir = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_DIR");
netcoreSdkVersion = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_VER");
}
if (msbuildSdksDir == null)
{
string dotnetExeDir = _netCoreSdkResolver.GetDotnetExeDirectory();
string globalJsonStartDir = Path.GetDirectoryName(context.SolutionFilePath ?? context.ProjectFilePath);
var resolverResult = _netCoreSdkResolver.ResolveNETCoreSdkDirectory(globalJsonStartDir, context.MSBuildVersion, context.IsRunningInVisualStudio, dotnetExeDir);
if (resolverResult.ResolvedSdkDirectory == null)
{
return(Failure(
factory,
Strings.UnableToLocateNETCoreSdk));
}
msbuildSdksDir = Path.Combine(resolverResult.ResolvedSdkDirectory, "Sdks");
netcoreSdkVersion = new DirectoryInfo(resolverResult.ResolvedSdkDirectory).Name;
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, sdkReference.MinimumVersion))
{
return(Failure(
factory,
Strings.NETCoreSDKSmallerThanMinimumRequestedVersion,
netcoreSdkVersion,
sdkReference.MinimumVersion));
}
Version minimumMSBuildVersion = _netCoreSdkResolver.GetMinimumMSBuildVersion(resolverResult.ResolvedSdkDirectory);
if (context.MSBuildVersion < minimumMSBuildVersion)
{
return(Failure(
factory,
Strings.MSBuildSmallerThanMinimumVersion,
netcoreSdkVersion,
minimumMSBuildVersion,
context.MSBuildVersion));
}
string minimumVSDefinedSDKVersion = GetMinimumVSDefinedSDKVersion();
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, minimumVSDefinedSDKVersion))
{
return(Failure(
factory,
Strings.NETCoreSDKSmallerThanMinimumVersionRequiredByVisualStudio,
netcoreSdkVersion,
minimumVSDefinedSDKVersion));
}
if (resolverResult.FailedToResolveSDKSpecifiedInGlobalJson)
{
if (warnings == null)
{
warnings = new List <string>();
}
warnings.Add(Strings.GlobalJsonResolutionFailed);
if (propertiesToAdd == null)
{
propertiesToAdd = new Dictionary <string, string>();
}
propertiesToAdd.Add("SdkResolverHonoredGlobalJson", "false");
propertiesToAdd.Add("SdkResolverGlobalJsonPath", resolverResult.GlobalJsonPath);
}
}
context.State = new CachedResult
{
MSBuildSdksDir = msbuildSdksDir,
NETCoreSdkVersion = netcoreSdkVersion
};
string msbuildSdkDir = Path.Combine(msbuildSdksDir, sdkReference.Name, "Sdk");
if (!Directory.Exists(msbuildSdkDir))
{
return(Failure(
factory,
Strings.MSBuildSDKDirectoryNotFound,
msbuildSdkDir));
}
return(factory.IndicateSuccess(msbuildSdkDir, netcoreSdkVersion, propertiesToAdd, itemsToAdd, warnings));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext context, SdkResultFactory factory)
{
// These are overrides that are used to force the resolved SDK tasks and targets to come from a given
// base directory and report a given version to msbuild (which may be null if unknown. One key use case
// for this is to test SDK tasks and targets without deploying them inside the .NET Core SDK.
string msbuildSdksDir = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_DIR");
string netcoreSdkVersion = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_VER");
if (msbuildSdksDir == null)
{
string netcoreSdkDir = ResolveNetcoreSdkDirectory(context);
if (netcoreSdkDir == null)
{
return(factory.IndicateFailure(
new[]
{
"Unable to locate the .NET Core SDK. Check that it is installed and that the version"
+ " specified in global.json (if any) matches the installed version."
}));
}
msbuildSdksDir = Path.Combine(netcoreSdkDir, "Sdks");
netcoreSdkVersion = new DirectoryInfo(netcoreSdkDir).Name;
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, sdkReference.MinimumVersion))
{
return(factory.IndicateFailure(
new[]
{
$"Version {netcoreSdkVersion} of the .NET Core SDK is smaller than the minimum version"
+ $" {sdkReference.MinimumVersion} requested. Check that a recent enough .NET Core SDK is"
+ " installed, increase the minimum version specified in the project, or increase"
+ " the version specified in global.json."
}));
}
string minimumMSBuildVersionString = GetMinimumMSBuildVersion(netcoreSdkDir);
var minimumMSBuildVersion = Version.Parse(minimumMSBuildVersionString);
if (context.MSBuildVersion < minimumMSBuildVersion)
{
return(factory.IndicateFailure(
new[]
{
$"Version {netcoreSdkVersion} of the .NET Core SDK requires at least version {minimumMSBuildVersionString}"
+ $" of MSBuild. The current available version of MSBuild is {context.MSBuildVersion.ToString()}."
+ " Change the .NET Core SDK specified in global.json to an older version that requires the MSBuild"
+ " version currently available."
}));
}
}
string msbuildSdkDir = Path.Combine(msbuildSdksDir, sdkReference.Name, "Sdk");
if (!Directory.Exists(msbuildSdkDir))
{
return(factory.IndicateFailure(
new[]
{
$"{msbuildSdkDir} not found. Check that a recent enough .NET Core SDK is installed"
+ " and/or increase the version specified in global.json."
}));
}
return(factory.IndicateSuccess(msbuildSdkDir, netcoreSdkVersion));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext, SdkResultFactory factory)
{
resolverContext.Logger.LogMessage($"{nameof(resolverContext.ProjectFilePath)} = {resolverContext.ProjectFilePath}", MessageImportance.High);
resolverContext.Logger.LogMessage($"{nameof(resolverContext.SolutionFilePath)} = {resolverContext.SolutionFilePath}", MessageImportance.High);
resolverContext.Logger.LogMessage($"{nameof(resolverContext.MSBuildVersion)} = {resolverContext.MSBuildVersion}", MessageImportance.High);
return(_mapping.ContainsKey(sdkReference.Name)
? factory.IndicateSuccess(_mapping[sdkReference.Name], null)
: factory.IndicateFailure(new[] { $"Not in {nameof(_mapping)}" }));
}
public override SdkResult Resolve(SdkReference sdkReference, SdkResolverContext context, SdkResultFactory factory)
{
string dotnetRoot = null;
string msbuildSdksDir = null;
string netcoreSdkVersion = null;
IDictionary <string, string> propertiesToAdd = null;
IDictionary <string, SdkResultItem> itemsToAdd = null;
List <string> warnings = null;
CachingWorkloadResolver workloadResolver = null;
if (context.State is CachedState priorResult)
{
dotnetRoot = priorResult.DotnetRoot;
msbuildSdksDir = priorResult.MSBuildSdksDir;
netcoreSdkVersion = priorResult.NETCoreSdkVersion;
propertiesToAdd = priorResult.PropertiesToAdd;
workloadResolver = priorResult.WorkloadResolver;
}
if (context.IsRunningInVisualStudio)
{
workloadResolver = _staticWorkloadResolver;
}
if (workloadResolver == null)
{
workloadResolver = new CachingWorkloadResolver();
}
if (msbuildSdksDir == null)
{
dotnetRoot = EnvironmentProvider.GetDotnetExeDirectory(_getEnvironmentVariable);
string globalJsonStartDir = Path.GetDirectoryName(context.SolutionFilePath ?? context.ProjectFilePath);
var resolverResult = _netCoreSdkResolver.ResolveNETCoreSdkDirectory(globalJsonStartDir, context.MSBuildVersion, context.IsRunningInVisualStudio, dotnetRoot);
if (resolverResult.ResolvedSdkDirectory == null)
{
return(Failure(
factory,
Strings.UnableToLocateNETCoreSdk));
}
msbuildSdksDir = Path.Combine(resolverResult.ResolvedSdkDirectory, "Sdks");
netcoreSdkVersion = new DirectoryInfo(resolverResult.ResolvedSdkDirectory).Name;
// These are overrides that are used to force the resolved SDK tasks and targets to come from a given
// base directory and report a given version to msbuild (which may be null if unknown. One key use case
// for this is to test SDK tasks and targets without deploying them inside the .NET Core SDK.
var msbuildSdksDirFromEnv = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_DIR");
var netcoreSdkVersionFromEnv = _getEnvironmentVariable("DOTNET_MSBUILD_SDK_RESOLVER_SDKS_VER");
if (!string.IsNullOrEmpty(msbuildSdksDirFromEnv))
{
msbuildSdksDir = msbuildSdksDirFromEnv;
}
if (!string.IsNullOrEmpty(netcoreSdkVersionFromEnv))
{
netcoreSdkVersion = netcoreSdkVersionFromEnv;
}
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, sdkReference.MinimumVersion))
{
return(Failure(
factory,
Strings.NETCoreSDKSmallerThanMinimumRequestedVersion,
netcoreSdkVersion,
sdkReference.MinimumVersion));
}
Version minimumMSBuildVersion = _netCoreSdkResolver.GetMinimumMSBuildVersion(resolverResult.ResolvedSdkDirectory);
if (context.MSBuildVersion < minimumMSBuildVersion)
{
return(Failure(
factory,
Strings.MSBuildSmallerThanMinimumVersion,
netcoreSdkVersion,
minimumMSBuildVersion,
context.MSBuildVersion));
}
string minimumVSDefinedSDKVersion = GetMinimumVSDefinedSDKVersion();
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, minimumVSDefinedSDKVersion))
{
return(Failure(
factory,
Strings.NETCoreSDKSmallerThanMinimumVersionRequiredByVisualStudio,
netcoreSdkVersion,
minimumVSDefinedSDKVersion));
}
if (resolverResult.FailedToResolveSDKSpecifiedInGlobalJson)
{
if (warnings == null)
{
warnings = new List <string>();
}
warnings.Add(Strings.GlobalJsonResolutionFailed);
if (propertiesToAdd == null)
{
propertiesToAdd = new Dictionary <string, string>();
}
propertiesToAdd.Add("SdkResolverHonoredGlobalJson", "false");
propertiesToAdd.Add("SdkResolverGlobalJsonPath", resolverResult.GlobalJsonPath);
}
}
context.State = new CachedState
{
DotnetRoot = dotnetRoot,
MSBuildSdksDir = msbuildSdksDir,
NETCoreSdkVersion = netcoreSdkVersion,
PropertiesToAdd = propertiesToAdd,
WorkloadResolver = workloadResolver
};
// First check if requested SDK resolves to a workload SDK pack
string userProfileDir = CliFolderPathCalculatorCore.GetDotnetUserProfileFolderPath();
var workloadResult = workloadResolver.Resolve(sdkReference.Name, dotnetRoot, netcoreSdkVersion, userProfileDir);
if (workloadResult is not CachingWorkloadResolver.NullResolutionResult)
{
return(workloadResult.ToSdkResult(sdkReference, factory));
}
string msbuildSdkDir = Path.Combine(msbuildSdksDir, sdkReference.Name, "Sdk");
if (!Directory.Exists(msbuildSdkDir))
{
return(Failure(
factory,
Strings.MSBuildSDKDirectoryNotFound,
msbuildSdkDir));
}
return(factory.IndicateSuccess(msbuildSdkDir, netcoreSdkVersion, propertiesToAdd, itemsToAdd, warnings));
}
public static SdkResult IndicateFailureAndLog(this SdkResultFactory factory, IEnumerable <string> errors, IEnumerable <string> warnings = null)
{
System.Windows.Forms.MessageBox.Show("Mono.UE4.Sdk failed. Reason: " + string.Join(Environment.NewLine, errors));
return(factory.IndicateFailure(errors, warnings));
}
