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 (!IsNetCoreSDKOveridden(netcoreSdkVersion) && IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, sdkReference.MinimumVersion)) { return(factory.IndicateFailure( new[] { $"Version {netcoreSdkVersion} of the 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 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 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) { 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 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 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) { 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}'" })); }
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 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" })); } }
private static SdkResult Failure(SdkResultFactory factory, string format, params object[] args) { return(factory.IndicateFailure(new[] { string.Format(format, args) })); }
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(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." })); } Version minimumMSBuildVersion = GetMinimumMSBuildVersion(netcoreSdkDir); if (context.MSBuildVersion < minimumMSBuildVersion) { return(factory.IndicateFailure( new[] { $"Version {netcoreSdkVersion} of the .NET Core SDK requires at least version {minimumMSBuildVersion.ToString()}" + $" 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 minimumVSDefinedSDKVersion = GetMinimumVSDefinedSDKVersion(); if (IsNetCoreSDKSmallerThanTheMinimumVersion(netcoreSdkVersion, minimumVSDefinedSDKVersion)) { return(factory.IndicateFailure( new[] { $"Version {netcoreSdkVersion} of the .NET Core SDK is smaller than the minimum version" + $" {minimumVSDefinedSDKVersion} required by Visual Studio. Check that a recent enough" + " .NET Core SDK is installed or increase the version specified in global.json." })); } } context.State = new CachedResult { MSBuildSdksDir = msbuildSdksDir, NETCoreSdkVersion = netcoreSdkVersion }; 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 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) { 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 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)); }