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 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);
}
}
return(factory.IndicateSuccess(autoImportSdkPaths, 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);
}
private void VerifyTryGetNuGetVersionForSdk(string version, NuGetVersion expectedVersion, SdkResolverContext context)
{
var result = NuGetSdkResolver.TryGetNuGetVersionForSdk(PackageA, version, context, out var parsedVersion);
if (expectedVersion != null)
{
result.Should().BeTrue();
parsedVersion.Should().NotBeNull();
parsedVersion.Should().Be(expectedVersion);
}
else
{
result.Should().BeFalse();
parsedVersion.Should().BeNull();
}
}
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,
Resources.GetString("UnableToLocateNETCoreSdk")));
}
msbuildSdksDir = Path.Combine(netcoreSdkDir, "Sdks");
netcoreSdkVersion = new DirectoryInfo(netcoreSdkDir).Name;
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, sdkReference.MinimumVersion))
{
return(Failure(
factory,
Resources.GetString("NETCoreSDKSmallerThanMinimumRequestedVersion"),
netcoreSdkVersion,
sdkReference.MinimumVersion));
}
Version minimumMSBuildVersion = GetMinimumMSBuildVersion(netcoreSdkDir);
if (context.MSBuildVersion < minimumMSBuildVersion)
{
return(Failure(
factory,
Resources.GetString("MSBuildSmallerThanMinimumVersion"),
netcoreSdkVersion,
minimumMSBuildVersion,
context.MSBuildVersion));
}
string minimumVSDefinedSDKVersion = GetMinimumVSDefinedSDKVersion();
if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, minimumVSDefinedSDKVersion))
{
return(Failure(
factory,
Resources.GetString("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,
Resources.GetString("MSBuildSDKDirectoryNotFound"),
msbuildSdkDir));
}
return(factory.IndicateSuccess(msbuildSdkDir, netcoreSdkVersion));
}
/// <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"/>.
/// <remarks>
/// Note: You must use the <see cref="SdkResultFactory" /> to return a result.
/// </remarks>
/// </returns>
public abstract SdkResult Resolve(SdkReference sdkReference, SdkResolverContext resolverContext,
SdkResultFactory factory);
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 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 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;
// Load NuGet settings and a path resolver
ISettings settings = Settings.LoadDefaultSettings(context.ProjectFilePath, configFileName: null, MachineWideSettings.Value as IMachineWideSettings, SettingsLoadContext.Value as SettingsLoadingContext);
var fallbackPackagePathResolver = new FallbackPackagePathResolver(NuGetPathContext.Create(settings));
var libraryIdentity = new LibraryIdentity(sdk.Name, parsedSdkVersion, LibraryType.Package);
var logger = new NuGetSdkLogger(context.Logger);
// Attempt to find a package if its already installed
if (!TryGetMSBuildSdkPackageInfo(fallbackPackagePathResolver, libraryIdentity, out var installedPath, out var installedVersion))
{
try
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(logger, nonInteractive: !context.Interactive);
// 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,
logger));
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
logger.LogError(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
logger.LogError(string.Format(CultureInfo.CurrentCulture, Strings.PackageWasNotInstalled, sdk, sdk.Name));
}
}
}
catch (Exception e)
{
logger.LogError(e.ToString());
}
finally
{
// The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger.
DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance);
}
}
if (logger.Errors.Count == 0)
{
return(factory.IndicateSuccess(path: installedPath, version: installedVersion, warnings: logger.Warnings));
}
return(factory.IndicateFailure(logger.Errors, logger.Warnings));
}
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
{
var nugetSDKLogger = new NuGetSdkLogger(context.Logger, warnings, errors);
DefaultCredentialServiceUtility.SetupDefaultCredentialService(nugetSDKLogger, nonInteractive: true);
// 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,
nugetSDKLogger)
.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));
}
