private BuildEventArgs ReadProjectStartedEventArgs() { var fields = ReadBuildEventArgsFields(); BuildEventContext parentContext = null; if (ReadBoolean()) { parentContext = ReadBuildEventContext(); } var projectFile = ReadOptionalString(); var projectId = ReadInt32(); var targetNames = ReadString(); var toolsVersion = ReadOptionalString(); var propertyList = ReadPropertyList(); var itemList = ReadItems(); var e = new ProjectStartedEventArgs( projectId, fields.Message, fields.HelpKeyword, projectFile, targetNames, propertyList, itemList, parentContext, null, toolsVersion); SetCommonFields(e, fields); return(e); }
void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e) { // ProjectStartedEventArgs adds ProjectFile, TargetNames // Just the regular message string is good enough here, so just display that. WriteLine(String.Empty, e); indent++; }
/// <summary> /// Raises a "project build started" event to all registered loggers. /// </summary> /// <owner>SumedhK</owner> /// <param name="sender"></param> /// <param name="e"></param> internal void RaiseProjectStartedEvent(object sender, ProjectStartedEventArgs e) { if (ProjectStarted != null) { try { ProjectStarted(sender, e); } catch (LoggerException) { // if a logger has failed politely, abort immediately // first unregister all loggers, since other loggers may receive remaining events in unexpected orderings // if a fellow logger is throwing in an event handler. this.UnregisterAllLoggers(); throw; } catch (Exception exception) { // first unregister all loggers, since other loggers may receive remaining events in unexpected orderings // if a fellow logger is throwing in an event handler. this.UnregisterAllLoggers(); InternalLoggerException.Throw(exception, e, "FatalErrorWhileLogging", false); } } RaiseStatusEvent(sender, e); }
/// <summary> /// Each time we encounter a new project, we want to load it, and grab the task registration information: /// - For the default tasks for its ToolsVersion /// - For any tasks registered in the project file or its imports /// </summary> private void HandleProjectStarted(object sender, ProjectStartedEventArgs e) { if (!ShouldIgnoreProject(e.ProjectFile)) { try { // Load up a private copy of the project. Project p = _privateCollection.LoadProject(e.ProjectFile, e.GlobalProperties, e.ToolsVersion); // Save off task registration information for this project GatherAndEvaluateDefaultTasksForToolsVersion(p.ToolsVersion, p); GatherAndEvaluateTasksForProject(p, e.BuildEventContext.ProjectContextId); // Keep a pointer to the ToolsVersion so that we'll be able to reference it // later. Index off ContextId since it appears to be globally unique within // the build. _toolsVersionsByProjectContextId[e.BuildEventContext.ProjectContextId] = p.ToolsVersion; // unload now that we're done with it. _privateCollection.UnloadProject(p); } catch (Exception ex) { throw new LoggerException(String.Format(CultureInfo.CurrentCulture, "Failed to load and read task registration information from project '{0}'. {1}", e.ProjectFile, ex.Message)); } } }
/// <summary> /// This is the delegate for ProjectStartedHandler events. /// </summary> private void ProjectStartedHandler(object sender, ProjectStartedEventArgs buildEvent) { if (LogAtImportance(MessageImportance.Low)) { LogEvent(sender, buildEvent); } }
public void VerifyEventType() { BuildFinishedEventArgs buildFinished = new BuildFinishedEventArgs("Message", "Keyword", true); BuildStartedEventArgs buildStarted = new BuildStartedEventArgs("Message", "Help"); BuildMessageEventArgs lowMessage = new BuildMessageEventArgs("Message", "help", "sender", MessageImportance.Low); TaskStartedEventArgs taskStarted = new TaskStartedEventArgs("message", "help", "projectFile", "taskFile", "taskName"); TaskFinishedEventArgs taskFinished = new TaskFinishedEventArgs("message", "help", "projectFile", "taskFile", "taskName", true); TaskCommandLineEventArgs commandLine = new TaskCommandLineEventArgs("commandLine", "taskName", MessageImportance.Low); BuildWarningEventArgs warning = new BuildWarningEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender"); BuildErrorEventArgs error = new BuildErrorEventArgs("SubCategoryForSchemaValidationErrors", "MSB4000", "file", 1, 2, 3, 4, "message", "help", "sender"); TargetStartedEventArgs targetStarted = new TargetStartedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile"); TargetFinishedEventArgs targetFinished = new TargetFinishedEventArgs("message", "help", "targetName", "ProjectFile", "targetFile", true); ProjectStartedEventArgs projectStarted = new ProjectStartedEventArgs(-1, "message", "help", "ProjectFile", "targetNames", null, null, null); ProjectFinishedEventArgs projectFinished = new ProjectFinishedEventArgs("message", "help", "ProjectFile", true); ExternalProjectStartedEventArgs externalStartedEvent = new ExternalProjectStartedEventArgs("message", "help", "senderName", "projectFile", "targetNames"); VerifyLoggingPacket(buildFinished, LoggingEventType.BuildFinishedEvent); VerifyLoggingPacket(buildStarted, LoggingEventType.BuildStartedEvent); VerifyLoggingPacket(lowMessage, LoggingEventType.BuildMessageEvent); VerifyLoggingPacket(taskStarted, LoggingEventType.TaskStartedEvent); VerifyLoggingPacket(taskFinished, LoggingEventType.TaskFinishedEvent); VerifyLoggingPacket(commandLine, LoggingEventType.TaskCommandLineEvent); VerifyLoggingPacket(warning, LoggingEventType.BuildWarningEvent); VerifyLoggingPacket(error, LoggingEventType.BuildErrorEvent); VerifyLoggingPacket(targetStarted, LoggingEventType.TargetStartedEvent); VerifyLoggingPacket(targetFinished, LoggingEventType.TargetFinishedEvent); VerifyLoggingPacket(projectStarted, LoggingEventType.ProjectStartedEvent); VerifyLoggingPacket(projectFinished, LoggingEventType.ProjectFinishedEvent); VerifyLoggingPacket(externalStartedEvent, LoggingEventType.CustomEvent); }
private void ProjectStarted(object sender, ProjectStartedEventArgs e) { string targets = string.IsNullOrEmpty(e.TargetNames) ? "default" : e.TargetNames; string line = string.Format(CultureInfo.InvariantCulture, "Project \"{0}\" ({1} target(s)):", e.ProjectFile, targets); this.WriteLine(line + Environment.NewLine); if (this.IsVerbosityAtLeast(LoggerVerbosity.Diagnostic)) { this.WriteLine("Initial Properties:"); SortedDictionary <string, string> sortedProperties = new SortedDictionary <string, string>(); foreach (DictionaryEntry k in e.Properties.Cast <DictionaryEntry>()) { sortedProperties.Add(k.Key.ToString(), k.Value.ToString()); } foreach (var p in sortedProperties) { bool matched = this.regExRules.Select(s => new Regex(s)).Select(r => r.Match(p.Key)).Any(m => m.Success); if (matched) { this.WriteLine(p.Key + "\t = " + SecureChar.Repeat(p.Value.Length)); } else { this.WriteLine(p.Key + "\t = " + p.Value); } } } }
/// <summary> /// Logs that a project build has started /// </summary> /// <param name="nodeBuildEventContext">The event context of the node which is spawning this project.</param> /// <param name="submissionId">The id of the submission.</param> /// <param name="projectInstanceId">Id of the project instance which is being started</param> /// <param name="parentBuildEventContext">BuildEventContext of the project who is requesting "projectFile" to build</param> /// <param name="projectFile">Project file to build</param> /// <param name="targetNames">Target names to build</param> /// <param name="properties">Initial property list</param> /// <param name="items">Initial items list</param> /// <param name="evaluationId">EvaluationId of the project instance</param> /// <returns>The build event context for the project.</returns> /// <exception cref="InternalErrorException">parentBuildEventContext is null</exception> /// <exception cref="InternalErrorException">projectBuildEventContext is null</exception> public BuildEventContext LogProjectStarted(BuildEventContext nodeBuildEventContext, int submissionId, int projectInstanceId, BuildEventContext parentBuildEventContext, string projectFile, string targetNames, IEnumerable <DictionaryEntry> properties, IEnumerable <DictionaryEntry> items, int evaluationId = BuildEventContext.InvalidEvaluationId) { lock (_lockObject) { ErrorUtilities.VerifyThrow(nodeBuildEventContext != null, "Need a nodeBuildEventContext"); BuildEventContext projectBuildEventContext = new BuildEventContext(submissionId, nodeBuildEventContext.NodeId, evaluationId, projectInstanceId, NextProjectId, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidTaskId); // PERF: Not using VerifyThrow to avoid boxing of projectBuildEventContext.ProjectContextId in the non-error case. if (_projectFileMap.ContainsKey(projectBuildEventContext.ProjectContextId)) { ErrorUtilities.ThrowInternalError("ContextID {0} for project {1} should not already be in the ID-to-file mapping!", projectBuildEventContext.ProjectContextId, projectFile); } _projectFileMap[projectBuildEventContext.ProjectContextId] = projectFile; ErrorUtilities.VerifyThrow(parentBuildEventContext != null, "Need a parentBuildEventContext"); string message = string.Empty; string projectFilePath = Path.GetFileName(projectFile); // Check to see if the there are any specific target names to be built. // If targetNames is null or empty then we will be building with the // default targets. if (!String.IsNullOrEmpty(targetNames)) { message = ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ProjectStartedPrefixForTopLevelProjectWithTargetNames", projectFilePath, targetNames); } else { message = ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("ProjectStartedPrefixForTopLevelProjectWithDefaultTargets", projectFilePath); } ErrorUtilities.VerifyThrow(_configCache.Value.HasConfiguration(projectInstanceId), "Cannot find the project configuration while injecting non-serialized data from out-of-proc node."); var buildRequestConfiguration = _configCache.Value[projectInstanceId]; // Always log GlobalProperties on ProjectStarted // See https://github.com/dotnet/msbuild/issues/6341 for details IDictionary <string, string> globalProperties = buildRequestConfiguration.GlobalProperties.ToDictionary(); var buildEvent = new ProjectStartedEventArgs ( projectInstanceId, message, helpKeyword: null, projectFile, targetNames, properties, items, parentBuildEventContext, globalProperties, buildRequestConfiguration.ToolsVersion ); buildEvent.BuildEventContext = projectBuildEventContext; ProcessLoggingEvent(buildEvent); return(projectBuildEventContext); } }
public void FireProjectStarted(object sender, ProjectStartedEventArgs psea) { if (projectStarted != null) { projectStarted(sender, psea); } FireAnyEvent(sender, psea); }
private void EventSource_ProjectStarted(object sender, ProjectStartedEventArgs e) { if (TextBox != null) { WriteLine("", e); m_iIndent++; } }
public ProjectState(ProjectStartedEventArgs args) { GlobalProperties = args.GlobalProperties; ProjectFile = args.ProjectFile; ContextId = args.BuildEventContext.ProjectContextId; ParentContextId = args.ParentProjectBuildEventContext.ProjectContextId; TargetPath = (string)args.Properties?.Cast <DictionaryEntry>().FirstOrDefault(p => ((string)p.Key).Equals("TargetPath")).Value; }
private void OnProjectStarted(object sender, ProjectStartedEventArgs e) { _projects.Add(new BuildProjectContextEntry( e.BuildEventContext.ProjectInstanceId, e.BuildEventContext.ProjectContextId, e.ProjectFile, e.GlobalProperties)); }
/// <summary> /// Handler for the ProjectStarted event. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e) { // Clone and store the properties so we can inspect the values later on foreach (DictionaryEntry property in e.Properties) { projectStartedProperties[(string)property.Key] = (string)property.Value; } }
private void OnProjectStarted(object sender, ProjectStartedEventArgs projectStartedEventArgs) { buildLog.ProjectStartEvents.Add(new ProjectStartLog { Time = projectStartedEventArgs.Timestamp.ToString(), Message = projectStartedEventArgs.Message, ProjectFile = projectStartedEventArgs.ProjectFile }); }
public void ProjectStartedHandler(object sender, ProjectStartedEventArgs args) { SetColor(eventColor); WriteLine(String.Format("Project \"{0}\" ({1} target(s)):", args.ProjectFile, String.IsNullOrEmpty(args.TargetNames) ? "default" : args.TargetNames)); ResetColor(); WriteLine(String.Empty); PushEvent(args); }
private void OnProjectStarted(object sender, ProjectStartedEventArgs e) { var entry = new BuildProjectContextEntry(e.ProjectFile, e.GlobalProperties); if (!_projectsLookup.ContainsKey(entry.ProjectFile)) { _projectsLookup.Add(entry.ProjectFile, entry); } }
/// <summary> /// Try to update the project data given a project started event. This is useful if the project /// was created (e.g. as a parent) before we saw the started event. /// <remarks>Does nothing if the data has already been set or the new data is null.</remarks> /// </summary> /// <param name="args">The <see cref="ProjectStartedEventArgs"/> instance containing the event data.</param> public void UpdateProject(Project project, ProjectStartedEventArgs args) { if (project.Name == null && args != null) { project.StartTime = args.Timestamp; project.Name = stringTable.Intern(args.Message); project.ProjectFile = stringTable.Intern(args.ProjectFile); if (args.GlobalProperties != null) { AddGlobalProperties(project, args.GlobalProperties); } if (args.Properties != null) { var properties = project.GetOrCreateNodeWithName <Folder>("Properties"); AddProperties(properties, args .Properties .Cast <DictionaryEntry>() .OrderBy(d => d.Key) .Select(d => new KeyValuePair <string, string>( stringTable.Intern(Convert.ToString(d.Key)), stringTable.Intern(Convert.ToString(d.Value))))); } if (args.Items != null) { RetrieveProjectInstance(project, args); var items = project.GetOrCreateNodeWithName <Folder>("Items"); foreach (DictionaryEntry kvp in args.Items) { var itemName = stringTable.Intern(Convert.ToString(kvp.Key)); var itemGroup = items.GetOrCreateNodeWithName <Folder>(itemName); var item = new Item(); var taskItem = kvp.Value as ITaskItem; if (taskItem != null) { item.Text = stringTable.Intern(taskItem.ItemSpec); foreach (DictionaryEntry metadataName in taskItem.CloneCustomMetadata()) { item.AddChild(new Metadata { Name = stringTable.Intern(Convert.ToString(metadataName.Key)), Value = stringTable.Intern(Convert.ToString(metadataName.Value)) }); } itemGroup.AddChild(item); } } } } }
/// <summary> /// Gets a project instance for the given identifier. Will create if it doesn't exist. /// </summary> /// <remarks>If the ProjectStartedEventArgs is not known at this time (null), a stub project is created.</remarks> /// <param name="projectId">The project identifier.</param> /// <param name="args">The <see cref="ProjectStartedEventArgs"/> instance containing the event data.</param> /// <param name="parentProject">The parent project, if any.</param> /// <returns>Project object</returns> public Project GetOrAddProject(ProjectStartedEventArgs args, Project parentProject = null) { var projectId = args.BuildEventContext.ProjectContextId; Project result = _projectIdToProjectMap.GetOrAdd(projectId, id => CreateProject(id)); UpdateProject(result, args); return(result); }
private void OnProjectStarted(object sender, ProjectStartedEventArgs e) { string prefix = ""; string suffix = ""; string project = Path.GetFileNameWithoutExtension(e.ProjectFile); switch (e.TargetNames) { case "Clean": return; // No need to show clean messages. case "GetCopyToOutputDirectoryItems": return; // No need to show "copying to target" messages. case "Rebuild": if (visited.Contains(project)) { return; } visited.Add(project); prefix = "Rebuilding "; break; case "Build": if (visited.Contains(project)) { return; } visited.Add(project); prefix = "Building "; break; case "GetNativeManifest": prefix = " Building manifest for "; break; case "GetResolvedLinkLibs": prefix = " Linking "; break; case "": if (visited.Contains(project)) { return; } visited.Add(project); break; default: suffix = " (" + e.TargetNames + ")"; break; } outputManager.EndProgress(); outputManager.StartProgress(prefix + project + suffix); }
internal PdbEntry ProjectStarted(ProjectStartedEventArgs e) { // Load symbol information for the project PDB pdb = SymbolStore.Instance[e.ProjectFile]; // Create a new stack frame projectStack.Push(new ProjectStackFrame(pdb)); // Return the symbol for the project return(pdb.ProjectPdbEntry); }
void ProjectStarted(object sender, ProjectStartedEventArgs e) { AppendLine(string.Format("##Project Started:{0}", e.ProjectFile)); AppendLine(string.Format(@"_{0}_<br/>", e.Message.EscapeMarkdownCharacters())); AppendLine(string.Format("_{0}|targets=({1})|{2}_", e.Timestamp, e.TargetNames, e.ProjectFile)); if (IsVerbosityAtLeast(LoggerVerbosity.Detailed)) { AppendLine(e.ToPropertyValues().ToMarkdownTable().ToMarkdown()); } }
private void EventSource_ProjectStarted(object sender, ProjectStartedEventArgs e) { if (DumpEnv) { o.WriteLine("Initial Properties:"); foreach (DictionaryEntry kvp in e.Properties) { o.WriteLine($"{kvp.Key} {kvp.Value}"); } } }
internal ProjectStartedEventMinimumFields(int projectKey, int entryPointKey, ProjectStartedEventArgs startedEvent, ProjectStartedEventMinimumFields parentProjectStartedEvent) { this.targetNames = startedEvent.TargetNames; this.projectFile = startedEvent.ProjectFile; this.showProjectFinishedEvent = false; this.errorInProject = false; this.projectId = startedEvent.ProjectId; this.buildEventContext = startedEvent.BuildEventContext; this.parentProjectStartedEvent = parentProjectStartedEvent; this.projectFullKey = new ProjectFullKey(projectKey, entryPointKey); this.timeStamp = startedEvent.Timestamp; }
private ProjectStartedEventArgs BuildProjectStartedEventArgs(long lineNumber, string line, string fullText) { var projectStartedEventArgs = new ProjectStartedEventArgs() { LineNumber = lineNumber, RegExResult = line, FullText = fullText, ProjectName = line }; return(projectStartedEventArgs); }
private void EventSourceOnProjectStarted(object sender, ProjectStartedEventArgs projectStartedEventArgs) { if (projectStartedEventArgs.ProjectFile.EndsWith(".sln", StringComparison.InvariantCultureIgnoreCase)) { return; } if (this.projectBuildStarted != null) { this.projectBuildStarted(projectStartedEventArgs.ProjectFile); } }
protected override void ProjectStartedHandler(object sender, ProjectStartedEventArgs buildEvent) { try { base.ProjectStartedHandler(sender, buildEvent); mustLog = true; } catch (Exception e) { System.Diagnostics.Debug.WriteLine(e.Message); } }
public void ProjectStartedHandler(ProjectStartedEventArgs args) { if (IsVerbosityGreaterOrEqual(LoggerVerbosity.Normal)) { SetColor(eventColor); WriteLine(String.Format("Project \"{0}\" ({1} target(s)):", args.ProjectFile, String.IsNullOrEmpty(args.TargetNames) ? "default" : args.TargetNames)); ResetColor(); DumpProperties(args.Properties); DumpItems(args.Items); } }
public BuildMessage(ProjectStartedEventArgs args) { EventType = args.GetType().Name.Replace("EventArgs", ""); Message = args.Message; ProjectFile = args.ProjectFile; ProjectId = args.ProjectId; TargetNames = args.TargetNames; HelpKeyword = args.HelpKeyword; SenderName = args.SenderName; Timestamp = args.Timestamp; ThreadId = args.ThreadId; }
/// <summary> /// Gets a project instance for the given identifier. Will create if it doesn't exist. /// </summary> /// <remarks>If the ProjectStartedEventArgs is not known at this time (null), a stub project is created.</remarks> /// <param name="projectId">The project identifier.</param> /// <param name="args">The <see cref="ProjectStartedEventArgs"/> instance containing the event data.</param> /// <param name="parentProject">The parent project, if any.</param> /// <returns>Project object</returns> public Project GetOrAddProject(int projectId, ProjectStartedEventArgs args = null, Project parentProject = null) { Project result = _projectIdToProjectMap.GetOrAdd(projectId, id => CreateProject(id)); if (args != null) { UpdateProject(result, args); } return(result); }
public void ExerciseBuildEventContext() { BuildEventContext parentBuildEventContext = new BuildEventContext(0, 0, 0, 0); BuildEventContext currentBuildEventContext = new BuildEventContext(0, 2, 1, 1); BuildEventContext currentBuildEventContextNode = new BuildEventContext(1, 0, 0, 0); BuildEventContext currentBuildEventContextTarget = new BuildEventContext(0, 1, 0, 0); BuildEventContext currentBuildEventContextPci = new BuildEventContext(0, 0, 1, 0); BuildEventContext currentBuildEventContextTask = new BuildEventContext(0, 0, 0, 1); BuildEventContext allDifferent = new BuildEventContext(1, 1, 1, 1); BuildEventContext allSame = new BuildEventContext(0, 0, 0, 0); ProjectStartedEventArgs startedEvent = new ProjectStartedEventArgs(-1, "Message", "HELP", "File", "Targets", null, null, parentBuildEventContext); startedEvent.BuildEventContext = currentBuildEventContext; Assert.IsTrue(parentBuildEventContext.GetHashCode() == 0); // Node is different Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextNode)); // Target is different Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextTarget)); // PCI is different Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextPci)); // Task is different Assert.IsFalse(parentBuildEventContext.Equals(currentBuildEventContextTask)); // All fields are different Assert.IsFalse(parentBuildEventContext.Equals(allDifferent)); // All fields are same Assert.IsTrue(parentBuildEventContext.Equals(allSame)); // Compare with null Assert.IsFalse(parentBuildEventContext.Equals(null)); // Compare with self Assert.IsTrue(currentBuildEventContext.Equals(currentBuildEventContext)); Assert.IsFalse(currentBuildEventContext.Equals(new object())); Assert.IsNotNull(startedEvent.BuildEventContext); Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.NodeId); Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.TargetId); Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.ProjectContextId); Assert.AreEqual(0, startedEvent.ParentProjectBuildEventContext.TaskId); Assert.AreEqual(0, startedEvent.BuildEventContext.NodeId); Assert.AreEqual(2, startedEvent.BuildEventContext.TargetId); Assert.AreEqual(1, startedEvent.BuildEventContext.ProjectContextId); Assert.AreEqual(1, startedEvent.BuildEventContext.TaskId); }
private void eventSource_ProjectStartedHandler(object sender, ProjectStartedEventArgs e) { LogStageStarted(XmlLoggerElements.Project, e.TargetNames, e.ProjectFile, e.Timestamp); }
void eventSource_ProjectStarted(object sender, ProjectStartedEventArgs e) { BuildDetails.Add(e.Message); }
private void ProjectStarted(object sender, ProjectStartedEventArgs e) { SendMessage(FormatMessage(e)); }