private static string GetLoggerValue(MSBuildLogger logger)
{
if (string.IsNullOrWhiteSpace(logger.Assembly))
{
throw new ArgumentNullException(nameof(logger.Assembly), "Assembly must be a strong name or file");
}
var argumentBuilder = new StringBuilder();
if (!string.IsNullOrWhiteSpace(logger.Class))
{
argumentBuilder.Append(logger.Class);
argumentBuilder.Append(",");
argumentBuilder.Append(logger.Assembly);
}
else
{
argumentBuilder.Append(logger.Assembly?.Quote());
}
if (!string.IsNullOrWhiteSpace(logger.Parameters))
{
argumentBuilder.Append(";");
argumentBuilder.Append(logger.Parameters);
}
return(argumentBuilder.ToString());
}
public void ItCanSendProperties()
{
var fakeTelemetry = new FakeTelemetry();
var telemetryEventArgs = new TelemetryEventArgs
{
EventName = "targetframeworkeval",
Properties = new Dictionary <string, string>
{
{ "TargetFrameworkVersion", ".NETFramework,Version=v4.6" },
{ "RuntimeIdentifier", "null" },
{ "SelfContained", "null" },
{ "UseApphost", "null" },
{ "OutputType", "Library" },
}
};
MSBuildLogger.FormatAndSend(fakeTelemetry, telemetryEventArgs);
fakeTelemetry.LogEntry.Properties.ShouldBeEquivalentTo(new Dictionary <string, string>
{
{ "TargetFrameworkVersion", "9a871d7066260764d4cb5047e4b10570271d04bd1da275681a4b12bce0b27496" },
{ "RuntimeIdentifier", "fb329000228cc5a24c264c57139de8bf854fc86fc18bf1c04ab61a2b5cb4b921" },
{ "SelfContained", "fb329000228cc5a24c264c57139de8bf854fc86fc18bf1c04ab61a2b5cb4b921" },
{ "UseApphost", "fb329000228cc5a24c264c57139de8bf854fc86fc18bf1c04ab61a2b5cb4b921" },
{ "OutputType", "d77982267d9699c2a57bcab5bb975a1935f6427002f52fd4569762fd72db3a94" },
});
}
public static Logger build(FileSystemAccess file_system, ConfigurationPropertyHolder configuration_property_holder)
{
IList <Logger> loggers = new List <Logger>();
Logger nant_logger = new NAntLogger(configuration_property_holder);
loggers.Add(nant_logger);
if (configuration_property_holder.MSBuildTask != null)
{
Logger msbuild_logger = new MSBuildLogger(configuration_property_holder);
loggers.Add(msbuild_logger);
}
Logger log4net_logger = new Log4NetLogger(configuration_property_holder.Log4NetLogger);
loggers.Add(log4net_logger);
//Logger file_logger = new FileLogger(
// combine_items_into_one_path(
// file_system,
// known_folders.change_drop.folder_full_path,
// string.Format("{0}_{1}.log", ApplicationParameters.name, known_folders.change_drop.folder_name)
// ),
// file_system
// );
//loggers.Add(file_logger);
return(new MultipleLogger(loggers));
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
// Log inputs
log.LogDebug($"(in) RestoreGraphItems Count '{RestoreGraphItems?.Count() ?? 0}'");
log.LogDebug($"(in) RestoreSources '{RestoreSources}'");
log.LogDebug($"(in) RestorePackagesPath '{RestorePackagesPath}'");
log.LogDebug($"(in) RestoreFallbackFolders '{RestoreFallbackFolders}'");
log.LogDebug($"(in) RestoreDisableParallel '{RestoreDisableParallel}'");
log.LogDebug($"(in) RestoreConfigFile '{RestoreConfigFile}'");
log.LogDebug($"(in) RestoreNoCache '{RestoreNoCache}'");
log.LogDebug($"(in) RestoreIgnoreFailedSources '{RestoreIgnoreFailedSources}'");
log.LogDebug($"(in) RestoreRecursive '{RestoreRecursive}'");
log.LogDebug($"(in) RestoreForce '{RestoreForce}'");
log.LogDebug($"(in) HideWarningsAndErrors '{HideWarningsAndErrors}'");
try
{
return(ExecuteAsync(log).Result);
}
catch (AggregateException ex) when(_cts.Token.IsCancellationRequested && ex.InnerException is TaskCanceledException)
{
// Canceled by user
log.LogError(Strings.RestoreCanceled);
return(false);
}
catch (Exception e)
{
ExceptionUtilities.LogException(e, log);
return(false);
}
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
log.LogDebug($"(in) ProjectPath '{ProjectPath}'");
log.LogDebug($"(in) TargetFrameworkMoniker '{TargetFrameworkMoniker}'");
log.LogDebug($"(in) TargetPlatformIdentifier '{TargetPlatformIdentifier}'");
log.LogDebug($"(in) TargetPlatformVersion '{TargetPlatformVersion}'");
log.LogDebug($"(in) TargetPlatformMinVersion '{TargetPlatformMinVersion}'");
log.LogDebug($"(in) TargetFrameworks '{TargetFrameworks}'");
log.LogDebug($"(in) TargetFramework '{TargetFramework}'");
// If no framework can be found this will return Unsupported.
var frameworks = MSBuildProjectFrameworkUtility.GetProjectFrameworkStrings(
projectFilePath: ProjectPath,
targetFrameworks: TargetFrameworks,
targetFramework: TargetFramework,
targetFrameworkMoniker: TargetFrameworkMoniker,
targetPlatformIdentifier: TargetPlatformIdentifier,
targetPlatformVersion: TargetPlatformVersion,
targetPlatformMinVersion: TargetPlatformMinVersion);
ProjectTargetFrameworks = string.Join(";", frameworks);
log.LogDebug($"(out) ProjectTargetFrameworks '{ProjectTargetFrameworks}'");
return(true);
}
public void ItMasksEventNameWithTargetframeworkevalOnTargetFrameworkVersionUseWindowsFormsOrWPF()
{
var fakeTelemetry = new FakeTelemetry();
var telemetryEventArgs = new TelemetryEventArgs
{
EventName = MSBuildLogger.TargetFrameworkTelemetryEventName,
Properties = new Dictionary <string, string>
{
{ MSBuildLogger.TargetFrameworkVersionTelemetryPropertyKey, ".NETStandard,Version=v2.0" },
{ MSBuildLogger.UseWindowsFormsTelemetryPropertyKey, "true" },
{ MSBuildLogger.UseWPFTelemetryPropertyKey, "AnyNonTrueValue" },
}
};
MSBuildLogger.FormatAndSend(fakeTelemetry, telemetryEventArgs);
fakeTelemetry.LogEntry.EventName.Should().Be($"msbuild/{MSBuildLogger.TargetFrameworkTelemetryEventName}");
fakeTelemetry.LogEntry.Properties.Keys.Count.Should().Be(3);
fakeTelemetry.LogEntry.Properties[MSBuildLogger.TargetFrameworkVersionTelemetryPropertyKey].Should().Be(Sha256Hasher.Hash(".NETSTANDARD,VERSION=V2.0"));
fakeTelemetry.LogEntry.Properties[MSBuildLogger.UseWindowsFormsTelemetryPropertyKey].Should().Be("True");
fakeTelemetry.LogEntry.Properties[MSBuildLogger.UseWPFTelemetryPropertyKey]
.Should().Be(
"False",
"sanitize to avoid user input, and since in SDK prop and target non 'true' is effectively false");
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
BuildTasksUtility.LogInputParam(log, nameof(CurrentProjectTargetFramework), CurrentProjectTargetFramework);
BuildTasksUtility.LogInputParam(log, nameof(AnnotatedProjectReferences),
AnnotatedProjectReferences == null
? ""
: string.Join(";", AnnotatedProjectReferences.Select(p => p.ItemSpec)));
if (AnnotatedProjectReferences == null)
{
return(!Log.HasLoggedErrors);
}
var frameworkToMatch = NuGetFramework.Parse(CurrentProjectTargetFramework);
if (frameworkToMatch.IsUnsupported)
{
log.LogError(string.Format(Strings.UnsupportedTargetFramework, CurrentProjectTargetFramework));
return(false);
}
AssignedProjects = new ITaskItem[AnnotatedProjectReferences.Length];
for (var index = 0; index < AnnotatedProjectReferences.Length; index++)
{
AssignedProjects[index] = AssignPropertiesForSingleReference(AnnotatedProjectReferences[index], frameworkToMatch);
}
BuildTasksUtility.LogOutputParam(log, nameof(AssignedProjects), string.Join(";", AssignedProjects.Select(p => p.ItemSpec)));
return(!Log.HasLoggedErrors);
}
/// <summary>
/// Indicates that a build session is starting
/// </summary>
public async Task BeginBuildOperation(ProgressMonitor monitor, MSBuildLogger logger, MSBuildVerbosity verbosity, ProjectConfigurationInfo[] configurations)
{
buildSessionLoggerId = RegisterLogger(monitor.Log, logger);
try {
var binLogPath = Path.ChangeExtension(Path.GetTempFileName(), "binlog");
await connection.SendMessage(new BeginBuildRequest {
BinLogFilePath = binLogPath,
LogWriterId = buildSessionLoggerId,
EnabledLogEvents = logger != null ? logger.EnabledEvents : MSBuildEvent.None,
Verbosity = verbosity,
Configurations = configurations
});
monitor.LogObject(new BuildSessionStartedEvent {
SessionId = buildSessionLoggerId,
LogFile = binLogPath,
TimeStamp = DateTime.Now
});
} catch {
UnregisterLogger(buildSessionLoggerId);
await CheckDisconnected();
throw;
}
}
private static Logger GetMultiLogger(ConfigurationPropertyHolder configuration_property_holder)
{
IList <Logger> loggers = new List <Logger>();
// This doesn't work on macOS, at least. Try, and fail silently.
try
{
var task = configuration_property_holder as ITask;
if (task != null)
{
Logger msbuild_logger = new MSBuildLogger(configuration_property_holder);
loggers.Add(msbuild_logger);
}
}
catch (FileNotFoundException)
{}
Logger log4net_logger = new Log4NetLogger(LogManager.GetLogger(typeof(ApplicationConfiguraton)));
loggers.Add(log4net_logger);
if (configuration_property_holder.Logger != null && !loggers.Contains(configuration_property_holder.Logger))
{
loggers.Add(configuration_property_holder.Logger);
}
return(new MultipleLogger(loggers));
}
private async Task <BuildResults> BuildAsync(string target = Targets.GetBuildVersion, LoggerVerbosity logVerbosity = LoggerVerbosity.Detailed, bool assertSuccessfulBuild = true)
{
var eventLogger = new MSBuildLogger {
Verbosity = LoggerVerbosity.Minimal
};
var loggers = new ILogger[] { eventLogger };
var buildResult = await this.buildManager.BuildAsync(
this.Logger,
this.projectCollection,
this.testProject,
target,
this.globalProperties,
logVerbosity,
loggers);
var result = new BuildResults(buildResult, eventLogger.LoggedEvents);
this.Logger.WriteLine(result.ToString());
if (assertSuccessfulBuild)
{
Assert.Equal(BuildResultCode.Success, buildResult.OverallResult);
}
return(result);
}
private static Logger GetMultiLogger(ConfigurationPropertyHolder configuration_property_holder)
{
IList <Logger> loggers = new List <Logger>();
var task = configuration_property_holder as ITask;
if (task != null)
{
Logger msbuild_logger = new MSBuildLogger(configuration_property_holder);
loggers.Add(msbuild_logger);
}
Logger log4net_logger = new Log4NetLogger(LogManager.GetLogger("roundhouse"));
loggers.Add(log4net_logger);
Logger sql_output = new Log4NetLogger(LogManager.GetLogger("roundhouse.sql.output"));
if (configuration_property_holder.Logger != null && !loggers.Contains(configuration_property_holder.Logger))
{
loggers.Add(configuration_property_holder.Logger);
}
return(new MultipleLogger(loggers, sql_output));
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
// Log inputs
log.LogDebug($"(in) RestoreGraphItems Count '{RestoreGraphItems?.Count() ?? 0}'");
log.LogDebug($"(in) RestoreSources '{RestoreSources}'");
log.LogDebug($"(in) RestorePackagesPath '{RestorePackagesPath}'");
log.LogDebug($"(in) RestoreFallbackFolders '{RestoreFallbackFolders}'");
log.LogDebug($"(in) RestoreDisableParallel '{RestoreDisableParallel}'");
log.LogDebug($"(in) RestoreConfigFile '{RestoreConfigFile}'");
log.LogDebug($"(in) RestoreNoCache '{RestoreNoCache}'");
log.LogDebug($"(in) RestoreIgnoreFailedSources '{RestoreIgnoreFailedSources}'");
log.LogDebug($"(in) RestoreRecursive '{RestoreRecursive}'");
try
{
return(ExecuteAsync(log).Result);
}
catch (Exception e)
{
ExceptionUtilities.HandleException(e, log);
return(false);
}
}
public override bool Execute()
{
var logger = new MSBuildLogger(Log);
BuildTasksUtility.LogInputParam(logger, nameof(CurrentProjectTargetFramework), CurrentProjectTargetFramework);
BuildTasksUtility.LogInputParam(logger, nameof(FallbackTargetFrameworks),
FallbackTargetFrameworks == null
? ""
: string.Join(";", FallbackTargetFrameworks.Select(p => p)));
BuildTasksUtility.LogInputParam(logger, nameof(AnnotatedProjectReferences),
AnnotatedProjectReferences == null
? ""
: string.Join(";", AnnotatedProjectReferences.Select(p => p.ItemSpec)));
if (AnnotatedProjectReferences == null)
{
return(!Log.HasLoggedErrors);
}
var fallbackNuGetFrameworks = new List <NuGetFramework>();
// validate current project framework
var errorMessage = string.Format(Strings.UnsupportedTargetFramework, CurrentProjectTargetFramework);
if (!TryParseFramework(CurrentProjectTargetFramework, errorMessage, logger, out var projectNuGetFramework))
{
return(false);
}
if (FallbackTargetFrameworks != null &&
FallbackTargetFrameworks.Length > 0)
{
foreach (var fallbackFramework in FallbackTargetFrameworks)
{
// validate ATF project frameworks
errorMessage = string.Format(Strings.UnsupportedFallbackFramework, fallbackFramework);
if (!TryParseFramework(fallbackFramework, errorMessage, logger, out var nugetFramework))
{
return(false);
}
else
{
fallbackNuGetFrameworks.Add(nugetFramework);
}
}
}
AssignedProjects = new ITaskItem[AnnotatedProjectReferences.Length];
for (var index = 0; index < AnnotatedProjectReferences.Length; index++)
{
AssignedProjects[index] = AssignNearestFrameworkForSingleReference(AnnotatedProjectReferences[index], projectNuGetFramework, fallbackNuGetFrameworks, logger);
}
BuildTasksUtility.LogOutputParam(logger, nameof(AssignedProjects), string.Join(";", AssignedProjects.Select(p => p.ItemSpec)));
return(!Log.HasLoggedErrors);
}
public override bool Execute()
{
// Log inputs
var log = new MSBuildLogger(Log);
log.LogDebug($"(in) ProjectUniqueName '{ProjectUniqueName}'");
log.LogDebug($"(in) TargetFrameworks '{TargetFrameworks}'");
log.LogDebug($"(in) ProjectReferences '{string.Join(";", ProjectReferences.Select(p => p.ItemSpec))}'");
log.LogDebug($"(in) ParentProjectPath '{ParentProjectPath}'");
var entries = new List <ITaskItem>();
// Filter obvious duplicates without considering OS case sensitivity.
// This will be filtered further when creating the spec.
var seen = new HashSet <string>(StringComparer.Ordinal);
var parentDirectory = Path.GetDirectoryName(ParentProjectPath);
foreach (var project in ProjectReferences)
{
var refOutput = BuildTasksUtility.GetPropertyIfExists(project, "ReferenceOutputAssembly");
// Match the same behavior as NuGet.targets
// ReferenceOutputAssembly == '' OR ReferenceOutputAssembly == 'true'
if (string.IsNullOrEmpty(refOutput) ||
Boolean.TrueString.Equals(refOutput, StringComparison.OrdinalIgnoreCase))
{
// Get the absolute path
var referencePath = Path.GetFullPath(Path.Combine(parentDirectory, project.ItemSpec));
if (!seen.Add(referencePath))
{
// Skip already processed projects
continue;
}
var properties = new Dictionary <string, string>();
properties.Add("ProjectUniqueName", ProjectUniqueName);
properties.Add("Type", "ProjectReference");
properties.Add("ProjectPath", referencePath);
properties.Add("ProjectReferenceUniqueName", referencePath);
if (!string.IsNullOrEmpty(TargetFrameworks))
{
properties.Add("TargetFrameworks", TargetFrameworks);
}
BuildTasksUtility.CopyPropertyIfExists(project, properties, "IncludeAssets");
BuildTasksUtility.CopyPropertyIfExists(project, properties, "ExcludeAssets");
BuildTasksUtility.CopyPropertyIfExists(project, properties, "PrivateAssets");
entries.Add(new TaskItem(Guid.NewGuid().ToString(), properties));
}
}
RestoreGraphItems = entries.ToArray();
return(true);
}
/// <summary>
/// Starts a build session that can span multiple builders and projects
/// </summary>
/// <returns>The build session handle.</returns>
/// <param name="tw">Log writter</param>
/// <param name="verbosity">MSBuild verbosity.</param>
internal static object StartBuildSession(TextWriter tw, MSBuildLogger logger, MSBuildVerbosity verbosity, ProjectConfigurationInfo[] configurations)
{
return(new SessionInfo {
Writer = tw,
Verbosity = verbosity,
Logger = logger,
Configurations = configurations
});
}
public override bool Execute()
{
#if DEBUG
var debugRestoreTask = Environment.GetEnvironmentVariable("DEBUG_RESTORE_TASK");
if (!string.IsNullOrEmpty(debugRestoreTask) && debugRestoreTask.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase))
{
#if IS_CORECLR
Console.WriteLine("Waiting for debugger to attach.");
Console.WriteLine($"Process ID: {Process.GetCurrentProcess().Id}");
while (!Debugger.IsAttached)
{
System.Threading.Thread.Sleep(100);
}
Debugger.Break();
#else
Debugger.Launch();
#endif
}
#endif
var log = new MSBuildLogger(Log);
// Log inputs
log.LogDebug($"(in) RestoreGraphItems Count '{RestoreGraphItems?.Count() ?? 0}'");
log.LogDebug($"(in) RestoreDisableParallel '{RestoreDisableParallel}'");
log.LogDebug($"(in) RestoreNoCache '{RestoreNoCache}'");
log.LogDebug($"(in) RestoreIgnoreFailedSources '{RestoreIgnoreFailedSources}'");
log.LogDebug($"(in) RestoreRecursive '{RestoreRecursive}'");
log.LogDebug($"(in) RestoreForce '{RestoreForce}'");
log.LogDebug($"(in) HideWarningsAndErrors '{HideWarningsAndErrors}'");
log.LogDebug($"(in) RestoreForceEvaluate '{RestoreForceEvaluate}'");
try
{
DefaultCredentialServiceUtility.SetupDefaultCredentialService(log, !Interactive);
return(ExecuteAsync(log).Result);
}
catch (AggregateException ex) when(_cts.Token.IsCancellationRequested && ex.InnerException is TaskCanceledException)
{
// Canceled by user
log.LogError(Strings.RestoreCanceled);
return(false);
}
catch (Exception e)
{
ExceptionUtilities.LogException(e, log);
return(false);
}
finally
{
// The CredentialService lifetime is for the duration of the process. We should not leave a potentially unavailable logger.
// We need to update the delegating logger with a null instance
// because the tear downs of the plugins and similar rely on idleness and process exit.
DefaultCredentialServiceUtility.UpdateCredentialServiceDelegatingLogger(NullLogger.Instance);
}
}
private ITaskItem AssignNearestFrameworkForSingleReference(
ITaskItem project,
NuGetFramework projectNuGetFramework,
IList <NuGetFramework> fallbackNuGetFrameworks,
MSBuildLogger logger)
{
var itemWithProperties = new TaskItem(project);
var referencedProjectFrameworkString = project.GetMetadata(TARGET_FRAMEWORKS);
var referencedProjectFile = project.GetMetadata(MSBUILD_SOURCE_PROJECT_FILE);
if (string.IsNullOrEmpty(referencedProjectFrameworkString))
{
// No target frameworks set, nothing to do.
return(itemWithProperties);
}
var referencedProjectFrameworks = MSBuildStringUtility.Split(referencedProjectFrameworkString);
// try project framework
var nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(referencedProjectFrameworks, projectNuGetFramework, NuGetFramework.Parse);
if (nearestNuGetFramework != null)
{
itemWithProperties.SetMetadata(NEAREST_TARGET_FRAMEWORK, nearestNuGetFramework);
return(itemWithProperties);
}
// try project fallback frameworks
foreach (var currentProjectTargetFramework in fallbackNuGetFrameworks)
{
nearestNuGetFramework = NuGetFrameworkUtility.GetNearest(referencedProjectFrameworks, currentProjectTargetFramework, NuGetFramework.Parse);
if (nearestNuGetFramework != null)
{
var message = string.Format(CultureInfo.CurrentCulture,
Strings.ImportsFallbackWarning,
referencedProjectFile,
currentProjectTargetFramework.DotNetFrameworkName,
projectNuGetFramework.DotNetFrameworkName);
var warning = RestoreLogMessage.CreateWarning(NuGetLogCode.NU1702, message);
warning.LibraryId = referencedProjectFile;
warning.ProjectPath = CurrentProjectName;
// log NU1702 for ATF on project reference
logger.Log(warning);
itemWithProperties.SetMetadata(NEAREST_TARGET_FRAMEWORK, nearestNuGetFramework);
return(itemWithProperties);
}
}
// no match found
logger.LogError(string.Format(Strings.NoCompatibleTargetFramework, project.ItemSpec, CurrentProjectTargetFramework, referencedProjectFrameworkString));
return(itemWithProperties);
}
/// <summary>
/// Starts a build session that can span multiple builders and projects
/// </summary>
/// <returns>The build session handle.</returns>
/// <param name="monitor">Progress monitor.</param>
/// <param name="verbosity">MSBuild verbosity.</param>
internal static object StartBuildSession(ProgressMonitor monitor, MSBuildLogger logger, MSBuildVerbosity verbosity, ProjectConfigurationInfo[] configurations)
{
CheckShutDown();
return(new SessionInfo {
Monitor = monitor,
Verbosity = verbosity,
Logger = logger,
Configurations = configurations
});
}
/// <summary>
/// Registers a logger to be used by the remote engine
/// </summary>
/// <returns>The logger id.</returns>
/// <remarks>Project builders register a logger and provide the logger id
/// to the remote project builders. The remote process sends log messages
/// that include the logger id, and this class redirects the log to
/// one of the registered loggers.</remarks>
public int RegisterLogger(TextWriter writer, MSBuildLogger logger)
{
lock (loggers) {
var i = loggerIdCounter++;
loggers [i] = new LoggerInfo {
Writer = writer, Logger = logger
};
return(i);
}
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
log.LogDebug($"(in) ProjectPath '{ProjectPath}'");
log.LogDebug($"(in) DotnetCliToolReferences '{string.Join(";", DotnetCliToolReferences.Select(p => p.ItemSpec))}'");
var entries = new List <ITaskItem>();
foreach (var msbuildItem in DotnetCliToolReferences)
{
if (string.IsNullOrEmpty(msbuildItem.ItemSpec))
{
throw new InvalidDataException($"Invalid DotnetCliToolReference in {ProjectPath}");
}
var uniqueName = $"{msbuildItem.ItemSpec}-{Guid.NewGuid().ToString()}";
// Create top level project
var properties = new Dictionary <string, string>();
properties.Add("ProjectUniqueName", uniqueName);
properties.Add("Type", "ProjectSpec");
properties.Add("ProjectPath", ProjectPath);
properties.Add("ProjectName", $"DotnetCliToolReference-{msbuildItem.ItemSpec}");
BuildTasksUtility.AddPropertyIfExists(properties, "Sources", RestoreSources);
BuildTasksUtility.AddPropertyIfExists(properties, "FallbackFolders", RestoreFallbackFolders);
BuildTasksUtility.AddPropertyIfExists(properties, "PackagesPath", RestorePackagesPath);
properties.Add("TargetFrameworks", ToolFramework);
properties.Add("ProjectStyle", ProjectStyle.DotnetCliTool.ToString());
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "Version");
entries.Add(new TaskItem(Guid.NewGuid().ToString(), properties));
// Add reference to package
var packageProperties = new Dictionary <string, string>();
packageProperties.Add("ProjectUniqueName", uniqueName);
packageProperties.Add("Type", "Dependency");
packageProperties.Add("Id", msbuildItem.ItemSpec);
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, packageProperties, "Version", "VersionRange");
packageProperties.Add("TargetFrameworks", ToolFramework);
entries.Add(new TaskItem(Guid.NewGuid().ToString(), packageProperties));
// Add restore spec to ensure this is executed during restore
var restoreProperties = new Dictionary <string, string>();
restoreProperties.Add("ProjectUniqueName", uniqueName);
restoreProperties.Add("Type", "RestoreSpec");
entries.Add(new TaskItem(Guid.NewGuid().ToString(), restoreProperties));
}
RestoreGraphItems = entries.ToArray();
return(true);
}
public async Task <bool> ExecuteAsync()
{
if (!DependencyVersionsFile.TryLoad(DependenciesFile, out var localVersionsFile))
{
Log.LogError($"Could not load file from {DependenciesFile}");
return(false);
}
if (!localVersionsFile.HasVersionsPropertyGroup())
{
Log.LogKoreBuildWarning(KoreBuildErrors.PackageRefPropertyGroupNotFound, $"No PropertyGroup with Label=\"{DependencyVersionsFile.PackageVersionsLabel}\" could be found in {DependenciesFile}");
}
if (localVersionsFile.VersionVariables.Count == 0)
{
Log.LogMessage(MessageImportance.High, $"No version variables could be found in {DependenciesFile}");
return(true);
}
var tmpNupkgPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
var logger = new MSBuildLogger(Log);
try
{
var remoteDepsVersionFile = await TryDownloadLineupDepsFile() ?? await TryDownloadLineupPackage(logger, tmpNupkgPath);
if (remoteDepsVersionFile == null)
{
return(false);
}
var updateCount = UpdateDependencies(localVersionsFile, remoteDepsVersionFile);
if (updateCount > 0)
{
Log.LogMessage($"Finished updating {updateCount} version variables in {DependenciesFile}");
localVersionsFile.Save(DependenciesFile);
}
else
{
Log.LogMessage($"Versions in {DependenciesFile} are already up to date");
}
return(!Log.HasLoggedErrors);
}
finally
{
if (File.Exists(tmpNupkgPath))
{
File.Delete(tmpNupkgPath);
}
}
}
private static bool TryParseFramework(string framework, string errorMessage, MSBuildLogger logger, out NuGetFramework nugetFramework)
{
nugetFramework = NuGetFramework.Parse(framework);
// validate framework
if (nugetFramework.IsUnsupported)
{
logger.LogError(errorMessage);
return(false);
}
return(true);
}
private async Task <DependencyVersionsFile> TryDownloadLineupPackage(MSBuildLogger logger, string tmpNupkgPath)
{
VersionRange versionRange;
if (string.IsNullOrEmpty(LineupPackageVersion))
{
versionRange = VersionRange.AllFloating;
}
else if (!VersionRange.TryParse(LineupPackageVersion, out versionRange))
{
Log.LogError($"{LineupPackageVersion} is not a valid NuGet package version");
return(null);
}
var packageVersion = await GetPackageVersion(versionRange);
if (packageVersion == null)
{
Log.LogError($"Could not find a version of {LineupPackageId} in the version range {versionRange}.");
return(null);
}
var packageId = new PackageIdentity(LineupPackageId, packageVersion);
var request = new PackageDownloadRequest
{
Identity = packageId,
OutputPath = tmpNupkgPath,
Sources = new[] { LineupPackageRestoreSource },
};
var result = await new PackageDownloader(logger).DownloadPackagesAsync(new[] { request }, TimeSpan.FromSeconds(60), _cts.Token);
if (!result)
{
Log.LogError("Could not download the lineup package");
return(null);
}
using (var nupkgReader = new PackageArchiveReader(tmpNupkgPath))
{
using (var stream = nupkgReader.GetStream("build/dependencies.props"))
{
using (var reader = new XmlTextReader(stream))
{
var projectRoot = ProjectRootElement.Create(reader);
return(DependencyVersionsFile.Load(projectRoot));
}
}
}
}
public Task <MSBuildResult> Run(
ProjectConfigurationInfo [] configurations,
TextWriter logWriter,
MSBuildLogger logger,
MSBuildVerbosity verbosity,
string [] runTargets,
string [] evaluateItems,
string [] evaluateProperties,
Dictionary <string, string> globalProperties,
CancellationToken cancellationToken
)
{
return(builder.Run(configurations, logWriter, logger, verbosity, runTargets, evaluateItems, evaluateProperties, globalProperties, cancellationToken));
}
void BuildInternal()
{
Engine engine = new Engine(Path.GetDirectoryName(new Uri(typeof(int).Assembly.CodeBase).LocalPath));
MSBuildLogger logger = new MSBuildLogger();
engine.GlobalProperties.SetProperty("Configuration", OtherConfiguration);
logger.Parameters = string.Format("OutputPath={0};Indent=true;VC-UpdateVersionInformation=true", LoggerPath);
engine.RegisterLogger(logger);
Project p = new Project(engine);
p.Load(Solution);
Assert.That(p.Build(), Is.True, "Build succeeded");
}
public override bool Execute()
{
#if DEBUG
var debugRestoreTask = Environment.GetEnvironmentVariable("DEBUG_RESTORE_TASK");
if (!string.IsNullOrEmpty(debugRestoreTask) && debugRestoreTask.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase))
{
#if IS_CORECLR
Console.WriteLine("Waiting for debugger to attach.");
Console.WriteLine($"Process ID: {Process.GetCurrentProcess().Id}");
while (!Debugger.IsAttached)
{
System.Threading.Thread.Sleep(100);
}
Debugger.Break();
#else
Debugger.Launch();
#endif
}
#endif
var log = new MSBuildLogger(Log);
// Log inputs
log.LogDebug($"(in) RestoreGraphItems Count '{RestoreGraphItems?.Count() ?? 0}'");
log.LogDebug($"(in) RestoreDisableParallel '{RestoreDisableParallel}'");
log.LogDebug($"(in) RestoreNoCache '{RestoreNoCache}'");
log.LogDebug($"(in) RestoreIgnoreFailedSources '{RestoreIgnoreFailedSources}'");
log.LogDebug($"(in) RestoreRecursive '{RestoreRecursive}'");
log.LogDebug($"(in) RestoreForce '{RestoreForce}'");
log.LogDebug($"(in) HideWarningsAndErrors '{HideWarningsAndErrors}'");
log.LogDebug($"(in) RestoreForceEvaluate '{RestoreForceEvaluate}'");
log.LogDebug($"(in) RestorePackagesConfig '{RestorePackagesConfig}'");
try
{
return(ExecuteAsync(log).Result);
}
catch (AggregateException ex) when(_cts.Token.IsCancellationRequested && ex.InnerException is TaskCanceledException)
{
// Canceled by user
log.LogError(Strings.RestoreCanceled);
return(false);
}
catch (Exception e)
{
ExceptionUtilities.LogException(e, log);
return(false);
}
}
public override bool Execute()
{
var log = new MSBuildLogger(Log);
log.LogDebug($"(in) ProjectUniqueName '{ProjectUniqueName}'");
log.LogDebug($"(in) TargetFrameworks '{TargetFrameworks}'");
log.LogDebug($"(in) PackageReferences '{string.Join(";", PackageReferences.Select(p => p.ItemSpec))}'");
var entries = new List <ITaskItem>();
var seenIds = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (var msbuildItem in PackageReferences)
{
var packageId = msbuildItem.ItemSpec;
if (string.IsNullOrEmpty(packageId) || !seenIds.Add(packageId))
{
// Skip empty or already processed ids
continue;
}
var properties = new Dictionary <string, string>();
properties.Add("ProjectUniqueName", ProjectUniqueName);
properties.Add("Type", "Dependency");
properties.Add("Id", packageId);
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "Version", "VersionRange");
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "VersionOverride");
if (!string.IsNullOrEmpty(TargetFrameworks))
{
properties.Add("TargetFrameworks", TargetFrameworks);
}
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "IncludeAssets");
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "ExcludeAssets");
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "PrivateAssets");
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "NoWarn");
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "IsImplicitlyDefined");
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "GeneratePathProperty");
BuildTasksUtility.CopyPropertyIfExists(msbuildItem, properties, "Aliases");
entries.Add(new TaskItem(Guid.NewGuid().ToString(), properties));
}
RestoreGraphItems = entries.ToArray();
return(true);
}
public void ItBlocksTelemetryThatIsNotInTheList()
{
var fakeTelemetry = new FakeTelemetry();
var telemetryEventArgs = new TelemetryEventArgs
{
EventName = "User Defined Event Name",
Properties = new Dictionary <string, string>
{
{ "User Defined Key", "User Defined Value" },
}
};
MSBuildLogger.FormatAndSend(fakeTelemetry, telemetryEventArgs);
fakeTelemetry.LogEntry.Should().BeNull();
}
public override bool Execute()
{
var logger = new MSBuildLogger(Log);
var globalProperties = GetGlobalProperties(logger);
if (globalProperties != null)
{
var dictionaryWithOrdinal = globalProperties.ToDictionary(i => i.Key, i => i.Value, StringComparer.OrdinalIgnoreCase);
CheckCompleted = true;
if (dictionaryWithOrdinal.TryGetValue(PropertyName, out string globalProperty))
{
GlobalPropertyValue = globalProperty;
}
}
return(!Log.HasLoggedErrors);
}
/// <summary>
/// Indicates that a build session is starting
/// </summary>
public async Task BeginBuildOperation(TextWriter logWriter, MSBuildLogger logger, MSBuildVerbosity verbosity, ProjectConfigurationInfo[] configurations)
{
buildSessionLoggerId = RegisterLogger(logWriter, logger);
try {
await connection.SendMessage(new BeginBuildRequest {
LogWriterId = buildSessionLoggerId,
EnabledLogEvents = logger != null ? logger.EnabledEvents : MSBuildEvent.None,
Verbosity = verbosity,
Configurations = configurations
});
} catch {
UnregisterLogger(buildSessionLoggerId);
await CheckDisconnected();
throw;
}
}
private async Task<BuildResults> BuildAsync(ProjectRootElement project, string target = Targets.GetBuildVersion, LoggerVerbosity logVerbosity = LoggerVerbosity.Detailed, bool assertSuccessfulBuild = true)
{
var eventLogger = new MSBuildLogger { Verbosity = LoggerVerbosity.Minimal };
var loggers = new ILogger[] { eventLogger };
var buildResult = await this.buildManager.BuildAsync(
this.Logger,
this.projectCollection,
project,
target,
this.globalProperties,
logVerbosity,
loggers);
var result = new BuildResults(buildResult, eventLogger.LoggedEvents);
this.Logger.WriteLine(result.ToString());
if (assertSuccessfulBuild)
{
Assert.Equal(BuildResultCode.Success, buildResult.OverallResult);
}
return result;
}
private static Logger GetMultiLogger(ConfigurationPropertyHolder configuration_property_holder)
{
IList<Logger> loggers = new List<Logger>();
var task = configuration_property_holder as ITask;
if (task != null)
{
Logger msbuild_logger = new MSBuildLogger(configuration_property_holder);
loggers.Add(msbuild_logger);
}
Logger log4net_logger = new Log4NetLogger(LogManager.GetLogger("roundhouse"));
loggers.Add(log4net_logger);
if (configuration_property_holder.Logger != null && !loggers.Contains(configuration_property_holder.Logger))
{
loggers.Add(configuration_property_holder.Logger);
}
return new MultipleLogger(loggers);
}
