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)); }