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