public void VerifySdkReferenceParseWith(string sdkString)
{
SdkReference sdk;
var parsed = SdkReference.TryParse(sdkString, out sdk);
Assert.False(parsed);
Assert.Null(sdk);
}
public void VerifySdkReferenceParseWith(string sdkString)
{
SdkReference sdk;
var parsed = SdkReference.TryParse(sdkString, out sdk);
parsed.ShouldBeFalse();
sdk.ShouldBeNull();
}
public SdkResultImpl(SdkReference sdkReference, string path, string version, IEnumerable <string> warnings)
{
Success = true;
Sdk = sdkReference;
Path = path;
Version = version;
Warnings = warnings;
}
/// <inheritdoc cref="ISdkResolverService.ResolveSdk"/>
public override SdkResult ResolveSdk(int submissionId, SdkReference sdk, LoggingContext loggingContext, ElementLocation sdkReferenceLocation, string solutionPath, string projectPath, bool interactive, bool isRunningInVisualStudio)
{
ErrorUtilities.VerifyThrowInternalNull(sdk, nameof(sdk));
ErrorUtilities.VerifyThrowInternalNull(loggingContext, nameof(loggingContext));
ErrorUtilities.VerifyThrowInternalNull(sdkReferenceLocation, nameof(sdkReferenceLocation));
ErrorUtilities.VerifyThrowInternalLength(projectPath, nameof(projectPath));
return(_cachedSdkResolver.ResolveSdk(submissionId, sdk, loggingContext, sdkReferenceLocation, solutionPath, projectPath, interactive, isRunningInVisualStudio));
}
/// <inheritdoc cref="ISdkResolverService.ResolveSdk"/>
public override SdkResult ResolveSdk(int submissionId, SdkReference sdk, LoggingContext loggingContext, ElementLocation sdkReferenceLocation, SdkEnv sdkEnv, bool interactive)
{
ErrorUtilities.VerifyThrowInternalNull(sdk, nameof(sdk));
ErrorUtilities.VerifyThrowInternalNull(loggingContext, nameof(loggingContext));
ErrorUtilities.VerifyThrowInternalNull(sdkReferenceLocation, nameof(sdkReferenceLocation));
ErrorUtilities.VerifyThrowInternalLength(sdkEnv.projectPath, nameof(sdkEnv.projectPath));
return(_cachedSdkResolver.ResolveSdk(submissionId, sdk, loggingContext, sdkReferenceLocation, sdkEnv, interactive));
}
public override SdkResultBase Resolve(SdkReference sdk, SdkResolverContextBase context, SdkResultFactoryBase 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 SdkResultImpl(SdkReference sdkReference, IEnumerable <string> paths, string version,
IDictionary <string, string> propertiesToAdd, IDictionary <string, SdkResultItem> itemsToAdd, IEnumerable <string> warnings)
: this(sdkReference, paths.FirstOrDefault(), version, propertiesToAdd, itemsToAdd, warnings)
{
if (paths.Count() > 1)
{
AdditionalPaths = paths.Skip(1).ToList();
}
}
/// <summary>
/// Determines if the <see cref="SdkReference"/> is the same as the specified version. If the <paramref name="sdk"/> object has <code>null</code> for the version,
/// this method will always return true since <code>null</code> can match any version.
/// </summary>
/// <param name="sdk">An <see cref="SdkReference"/> object.</param>
/// <param name="version">The version to compare.</param>
/// <returns><code>true</code> if the specified SDK reference has the same version as the specified result, otherwise <code>false</code>.</returns>
public static bool IsReferenceSameVersion(SdkReference sdk, string version)
{
// If the reference has a null version, it matches any result
if (String.IsNullOrEmpty(sdk.Version))
{
return(true);
}
return(String.Equals(sdk.Version, version, StringComparison.OrdinalIgnoreCase));
}
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 void AssertFirstResolverCanResolve()
{
var sdk = new SdkReference("1sdkName", "referencedVersion", "minimumVersion");
SdkResolution resolution = new SdkResolution(new MockLoaderStrategy());
var result = resolution.GetSdkPath(sdk, _loggingContext, new MockElementLocation("file"), "sln", "projectPath");
Assert.Equal("resolverpath1", result);
Assert.Equal("MockSdkResolver1 running", _log.ToString().Trim());
}
public override SdkResult Resolve(SdkReference sdk, SdkResolverContext resolverContext,
SdkResultFactory factory)
{
return(sdk.Name switch
{
SdkName when sdk.Version == SdkExpectedVersion =>
factory.IndicateSuccess(ResolvedPath, SdkExpectedVersion),
SdkName => factory.IndicateFailure(new[] { ErrorVersion }),
_ => factory.IndicateFailure(new[] { ErrorName })
});
public override Framework.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 SdkResultBase Resolve(SdkReference sdk, SdkResolverContextBase resolverContext, SdkResultFactoryBase factory)
{
resolverContext.Logger.LogMessage("MockSdkResolver1 running", MessageImportance.Normal);
if (sdk.Name.StartsWith("1"))
{
return(factory.IndicateSuccess("resolverpath1", "version1"));
}
return(factory.IndicateFailure(new[] { "ERROR1" }));
}
public void AssertFirstResolverCanResolve()
{
SdkResolverService.Instance.InitializeForTests(new MockLoaderStrategy());
SdkReference sdk = new SdkReference("1sdkName", "referencedVersion", "minimumVersion");
var result = SdkResolverService.Instance.ResolveSdk(BuildEventContext.InvalidSubmissionId, sdk, _loggingContext, new MockElementLocation("file"), "sln", "projectPath", interactive: false, isRunningInVisualStudio: false);
result.Path.ShouldBe("resolverpath1");
_logger.BuildMessageEvents.Select(i => i.Message).ShouldContain("MockSdkResolver1 running");
}
public override SdkResultBase Resolve(SdkReference sdk, SdkResolverContextBase resolverContext, SdkResultFactoryBase factory)
{
resolverContext.Logger.LogMessage("MockSdkResolverWithResolvableSdkPattern2 running", MessageImportance.Normal);
if (sdk.Name.StartsWith("2"))
{
return(factory.IndicateSuccess("resolverpathwithresolvablesdkpattern2", "version4", new[] { "WARNING4" }));
}
return(factory.IndicateFailure(new[] { "ERROR4" }, new[] { "WARNING4" }));
}
public void AssertErrorLoggedWhenResolverThrows()
{
SdkResolverService.Instance.InitializeForTests(new MockLoaderStrategy(includeErrorResolver: true));
SdkReference sdk = new SdkReference("1sdkName", "referencedVersion", "minimumVersion");
string result = SdkResolverService.Instance.ResolveSdk(BuildEventContext.InvalidSubmissionId, sdk, _loggingContext, new MockElementLocation("file"), "sln", "projectPath");
Assert.Equal("resolverpath1", result);
Assert.Contains("EXMESSAGE", _log.ToString());
}
public void VerifySdkReferenceParseNoVersion()
{
string sdkString = "Name";
SdkReference sdk;
var parsed = SdkReference.TryParse(sdkString, out sdk);
Assert.True(parsed);
Assert.Equal("Name", sdk.Name);
Assert.Null(sdk.Version);
Assert.Null(sdk.MinimumVersion);
}
public void AssertErrorLoggedWhenResolverThrows()
{
SdkResolverService.Instance.InitializeForTests(new MockLoaderStrategy(includeErrorResolver: true));
SdkReference sdk = new SdkReference("1sdkName", "version1", "minimumVersion");
var result = SdkResolverService.Instance.ResolveSdk(BuildEventContext.InvalidSubmissionId, sdk, _loggingContext, new MockElementLocation("file"), "sln", "projectPath", interactive: false, isRunningInVisualStudio: false);
result.Path.ShouldBe("resolverpath1");
_logger.Warnings.Select(i => i.Message).ShouldBe(new [] { "The SDK resolver \"MockSdkResolverThrows\" failed to run. EXMESSAGE" });
}
public SdkResultImpl(SdkReference sdkReference, string path, string version,
IDictionary <string, string> propertiesToAdd, IDictionary <string, SdkResultItem> itemsToAdd, IEnumerable <string> warnings)
{
Success = true;
Sdk = sdkReference;
PropertiesToAdd = propertiesToAdd;
ItemsToAdd = itemsToAdd;
Path = path;
Version = version;
Warnings = warnings;
}
public virtual SdkResult ResolveSdk(int submissionId, SdkReference sdk, LoggingContext loggingContext, ElementLocation sdkReferenceLocation, string solutionPath, string projectPath, bool interactive, bool isRunningInVisualStudio)
{
if (ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave17_4))
{
return(ResolveSdkUsingResolversWithPatternsFirst(submissionId, sdk, loggingContext, sdkReferenceLocation, solutionPath, projectPath, interactive, isRunningInVisualStudio));
}
else
{
return(ResolveSdkUsingAllResolvers(submissionId, sdk, loggingContext, sdkReferenceLocation, solutionPath, projectPath, interactive, isRunningInVisualStudio));
}
}
public void AssertFirstResolverCanResolve()
{
SdkResolverService.Instance.InitializeForTests(new MockLoaderStrategy());
SdkReference sdk = new SdkReference("1sdkName", "referencedVersion", "minimumVersion");
string result = SdkResolverService.Instance.ResolveSdk(BuildEventContext.InvalidSubmissionId, sdk, _loggingContext, new MockElementLocation("file"), "sln", "projectPath");
Assert.Equal("resolverpath1", result);
Assert.Contains("MockSdkResolver1 running", _log.ToString().Trim());
}
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" }));
}
/// <summary>
/// Processes all requests that are currently in the queue.
/// </summary>
private void ProcessRequests()
{
// Store a list of threads which are resolving SDKs
List <Task> tasks = new List <Task>(_requests.Count);
SdkResolverRequest item;
while (_requests.TryDequeue(out item))
{
SdkResolverRequest request = item;
// Start a thread to resolve an SDK and add it to the list of threads
tasks.Add(Task.Run(() =>
{
SdkResult response = null;
try
{
// Create an SdkReference from the request
SdkReference sdkReference = new SdkReference(request.Name, request.Version, request.MinimumVersion);
ILoggingService loggingService = Host.GetComponent(BuildComponentType.LoggingService) as ILoggingService;
// This call is usually cached so is very fast but can take longer for a new SDK that is downloaded. Other queued threads for different SDKs will complete sooner and continue on which unblocks evaluations
response = ResolveSdk
(
request.SubmissionId,
sdkReference,
new EvaluationLoggingContext(loggingService, request.BuildEventContext, request.ProjectPath),
request.ElementLocation,
new SdkEnv(request.SolutionPath, request.ProjectPath),
request.Interactive
);
}
catch (Exception e)
{
ILoggingService loggingService = Host.GetComponent(BuildComponentType.LoggingService) as ILoggingService;
EvaluationLoggingContext loggingContext = new EvaluationLoggingContext(loggingService, request.BuildEventContext, request.ProjectPath);
loggingService.LogFatalBuildError(loggingContext.BuildEventContext, e, new BuildEventFileInfo(request.ElementLocation));
}
finally
{
// Get the node manager and send the response back to the node that requested the SDK
INodeManager nodeManager = Host.GetComponent(BuildComponentType.NodeManager) as INodeManager;
nodeManager.SendData(request.NodeId, response);
}
}));
}
// Wait for all tasks to complete
Task.WaitAll(tasks.ToArray());
}
public void VerifySdkReferenceParseNoVersion()
{
string sdkString = "Name";
SdkReference sdk;
var parsed = SdkReference.TryParse(sdkString, out sdk);
parsed.ShouldBeTrue();
sdk.Name.ShouldBe("Name");
sdk.Version.ShouldBeNull();
sdk.MinimumVersion.ShouldBeNull();
}
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 void VerifySdkReferenceParseWithWhitespace()
{
string sdkString = " \r\n \t Name \t \n \n \r / min=Version \t ";
SdkReference sdk;
var parsed = SdkReference.TryParse(sdkString, out sdk);
Assert.True(parsed);
Assert.Equal("Name", sdk.Name);
Assert.Null(sdk.Version);
Assert.Equal("Version", sdk.MinimumVersion);
Assert.Equal("Name/min=Version", sdk.ToString());
}
/// <summary>
/// Get path on disk to the referenced SDK.
/// </summary>
/// <param name="sdk">SDK referenced by the Project.</param>
/// <param name="logger">Logging service.</param>
/// <param name="buildEventContext">Build event context for logging.</param>
/// <param name="projectFile">Location of the element within the project which referenced the SDK.</param>
/// <param name="solutionPath">Path to the solution if known.</param>
/// <returns>Path to the root of the referenced SDK.</returns>
internal string GetSdkPath(SdkReference sdk, ILoggingService logger, MSBuildContext buildEventContext,
string projectFile, string solutionPath)
{
if (_resolvers == null)
{
Initialize(logger);
}
var results = new List <SdkResultImpl> ();
try {
var buildEngineLogger = new SdkLoggerImpl(logger, buildEventContext);
foreach (var sdkResolver in _resolvers)
{
var context = new SdkResolverContextImpl(buildEngineLogger, projectFile, solutionPath, msbuildVersion);
var resultFactory = new SdkResultFactoryImpl(sdk);
try {
var result = (SdkResultImpl)sdkResolver.Resolve(sdk, context, resultFactory);
if (result != null && result.Success)
{
LogWarnings(logger, buildEventContext, projectFile, result);
return(result.Path);
}
if (result != null)
{
results.Add(result);
}
} catch (Exception e) {
logger.LogFatalBuildError(buildEventContext, e, projectFile);
}
}
} catch (Exception e) {
logger.LogFatalBuildError(buildEventContext, e, projectFile);
throw;
}
foreach (var result in results)
{
LogWarnings(logger, buildEventContext, projectFile, result);
if (result.Errors != null)
{
foreach (var error in result.Errors)
{
logger.LogErrorFromText(buildEventContext, subcategoryResourceName: null, errorCode: null,
helpKeyword: null, file: projectFile, message: error);
}
}
}
return(null);
}
public void SdkResultCanReturnMultiplePaths(bool includePropertiesAndItems)
{
string expectedPath1 = "First/Path/To/Return/From/Resolver";
string expectedPath2 = "Second/Path/To/Return/From/Resolver";
var sdk = new SdkReference("foo", "1.0", null);
Dictionary <string, string> propertiesToAdd = null;
Dictionary <string, SdkResultItem> itemsToAdd = null;
if (includePropertiesAndItems)
{
CreateMockSdkResultPropertiesAndItems(out propertiesToAdd, out itemsToAdd);
}
var resolver = new SdkUtilities.ConfigurableMockSdkResolver(
new SdkResultImpl(
sdk,
new []
{
expectedPath1,
expectedPath2
},
version: "1.0",
propertiesToAdd,
itemsToAdd,
warnings: null
));
SdkResolverService.Instance.InitializeForTests(null, new List <SdkResolver>()
{
resolver
});
var result = SdkResolverService.Instance.ResolveSdk(BuildEventContext.InvalidSubmissionId, sdk, _loggingContext, new MockElementLocation("file"), "sln", "projectPath", interactive: false, isRunningInVisualStudio: false);
result.Success.ShouldBeTrue();
var resultPaths = new List <string>();
resultPaths.Add(result.Path);
resultPaths.AddRange(result.AdditionalPaths);
resultPaths.ShouldBeSameIgnoringOrder(new[]
{
expectedPath1,
expectedPath2
});
ValidateExpectedPropertiesAndItems(includePropertiesAndItems, result);
_logger.WarningCount.ShouldBe(0);
}
public void VerifySdkReferenceParseWithWhitespace()
{
string sdkString = " \r\n \t Name \t \n \n \r / min=Version \t ";
SdkReference sdk;
var parsed = SdkReference.TryParse(sdkString, out sdk);
parsed.ShouldBeTrue();
sdk.Name.ShouldBe("Name");
sdk.Version.ShouldBeNull();
sdk.MinimumVersion.ShouldBe("Version");
sdk.ToString().ShouldBe("Name/min=Version");
}
public void AssertResolverThrows()
{
SdkResolverService.Instance.InitializeForTests(new MockLoaderStrategy(includeErrorResolver: true));
SdkReference sdk = new SdkReference("1sdkName", "version1", "minimumVersion");
// When an SDK resolver throws, the expander will catch it and stop the build.
SdkResolverException e = Should.Throw <SdkResolverException>(() => SdkResolverService.Instance.ResolveSdk(BuildEventContext.InvalidSubmissionId, sdk, _loggingContext, new MockElementLocation("file"), "sln", "projectPath", interactive: false, isRunningInVisualStudio: false));
e.Resolver.Name.ShouldBe("MockSdkResolverThrows");
e.Sdk.Name.ShouldBe("1sdkName");
}
