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 eventSource_TargetFinished(object sender, Microsoft.Build.Framework.TargetFinishedEventArgs e) { if (needToLog) { needToLog = false; } }
public void EventArgsCtors() { List<ITaskItem> outputs = new List<ITaskItem>(); TargetFinishedEventArgs targetFinishedEvent = new TargetFinishedEventArgs2(); targetFinishedEvent = new TargetFinishedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", true); targetFinishedEvent = new TargetFinishedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", true, DateTime.Now, outputs); targetFinishedEvent = new TargetFinishedEventArgs(null, null, null, null, null, true); targetFinishedEvent = new TargetFinishedEventArgs(null, null, null, null, null, true, DateTime.Now, null); }
public void TestSendsAbsoluteFileThreadSafeUsesStack() { TargetStartedEventArgs s1 = MakeTargetStartedEventArgs("/home/samantha/work/module1/module1.csproj"); TargetStartedEventArgs s2 = MakeTargetStartedEventArgs("/home/samantha/work/module2/module2.csproj"); logger.TargetStarted(this, s1); logger.TargetStarted(this, s2); TargetFinishedEventArgs f1 = new TargetFinishedEventArgs("", "", "", s2.ProjectFile, s2.ProjectFile, true); f1.BuildEventContext = s1.BuildEventContext; logger.TargetFinished(this, f1); logger.BuildErrorRaised(this, MakeBuildErrorEventArgs()); Assert.That(files.Count, Is.EqualTo(1)); Assert.That(Path.IsPathRooted(files[0]), Is.True); Assert.That(files[0], Text.Contains("module1")); }
public void AssignmentTest () { TargetFinishedEventArgs tfea; string message = "message"; string helpKeyword = "helpKeyword"; string targetName = "targetName"; string projectFile = "projectFile"; string targetFile = "targetFile"; bool succeeded = true; tfea = new TargetFinishedEventArgs (message, helpKeyword, targetName, projectFile, targetFile, succeeded); Assert.AreEqual (message, tfea.Message, "Message"); Assert.AreEqual (helpKeyword, tfea.HelpKeyword, "HelpKeyword"); Assert.AreEqual (targetName, tfea.TargetName, "TargetName"); Assert.AreEqual (projectFile, tfea.ProjectFile, "ProjectFile"); Assert.AreEqual (targetFile, tfea.TargetFile, "TargetFile"); Assert.AreEqual (succeeded, tfea.Succeeded, "Succeeded"); }
/// <summary> /// Translate the TargetOutputs for the target finished event. /// </summary> private static void TranslateTargetFinishedEvent(INodePacketTranslator translator, TargetFinishedEventArgs finishedEvent) { List<TaskItem> targetOutputs = null; if (translator.Mode == TranslationDirection.WriteToStream) { if (finishedEvent.TargetOutputs != null) { targetOutputs = new List<TaskItem>(); foreach (TaskItem item in finishedEvent.TargetOutputs) { targetOutputs.Add(item); } } } translator.Translate<TaskItem>(ref targetOutputs, TaskItem.FactoryForDeserialization); if (translator.Mode == TranslationDirection.ReadFromStream) { finishedEvent.TargetOutputs = targetOutputs; } }
void TargetFinished(object sender, TargetFinishedEventArgs e) { var startInfo = _targetsStarted.Pop(); // var execInfo = new TargetExecutionInfo(startInfo.TargetStartedArgs, e); var execInfo = new TargetExecutionInfo(startInfo.TargetStartedArgs, e); // see if the target is already in the executed list TargetExecutionInfo previoudExecInfo; this._targetsExecuted.TryGetValue(e.TargetName, out previoudExecInfo); if (previoudExecInfo != null) { execInfo.TimeSpent = execInfo.TimeSpent.Add(previoudExecInfo.TimeSpent); } this._targetsExecuted[execInfo.Name] = execInfo; AppendLine(string.Format("####TargetFinished:{0}", e.Message.EscapeMarkdownCharacters())); }
void LogTargetFinished (Target target, bool succeeded) { TargetFinishedEventArgs tfea; string projectFile = project.FullFileName; tfea = new TargetFinishedEventArgs (String.Format ("Target {0} finished.", target.Name), null, target.Name, projectFile, target.TargetFile, succeeded); target.Engine.EventSource.FireTargetFinished (this, tfea); }
public abstract void TargetFinishedHandler(object sender, TargetFinishedEventArgs e);
private void eventSource_TargetFinishedHandler(object sender, TargetFinishedEventArgs e) { LogStageFinished(e.Succeeded, e.Timestamp); }
public void TestLoggingEventCustomerSerialization() { Hashtable loggingTypeCacheWrites = new Hashtable(); stream.Position = 0; BuildEventContext context = new BuildEventContext(1,3,5,7); GenericBuildEventArg genericBuildEvent = new GenericBuildEventArg("Message","Help","Sender"); genericBuildEvent.BuildEventContext = context; NodeLoggingEvent genericBuildEventLoggingEvent = new NodeLoggingEvent(genericBuildEvent); genericBuildEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); GenericCustomBuildEventArg genericCustomEvent = new GenericCustomBuildEventArg("FooFighter"); genericCustomEvent.BuildEventContext = context; NodeLoggingEvent genericCustomEventLoggingEvent = new NodeLoggingEvent(genericCustomEvent); genericCustomEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); BuildErrorEventArgs errorEvent = new BuildErrorEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "SenderName"); errorEvent.BuildEventContext = context; NodeLoggingEvent errorEventLoggingEvent = new NodeLoggingEvent(errorEvent); errorEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); BuildMessageEventArgs messageEvent = new BuildMessageEventArgs("Message", "HelpKeyword", "SenderName",MessageImportance.High); messageEvent.BuildEventContext = context; NodeLoggingEvent messageEventLoggingEvent = new NodeLoggingEvent(messageEvent); messageEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); BuildWarningEventArgs warningEvent = new BuildWarningEventArgs("Subcategory", "Code", "File", 1, 2, 3, 4, "Message", "HelpKeyword", "SenderName"); warningEvent.BuildEventContext = context; NodeLoggingEvent warningEventLoggingEvent = new NodeLoggingEvent(warningEvent); warningEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); ProjectStartedEventArgs projectStartedEvent = new ProjectStartedEventArgs( 8,"Message", "HelpKeyword", "ProjectFile", "TargetNames", null, null, new BuildEventContext(7,8,9,10)); projectStartedEvent.BuildEventContext = context; NodeLoggingEvent projectStartedEventLoggingEvent = new NodeLoggingEvent(projectStartedEvent); projectStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); ProjectFinishedEventArgs projectFinishedEvent = new ProjectFinishedEventArgs("Message", "HelpKeyword","ProjectFile",true); projectFinishedEvent.BuildEventContext = context; NodeLoggingEvent projectFinishedEventLoggingEvent = new NodeLoggingEvent(projectFinishedEvent); projectFinishedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); TargetStartedEventArgs targetStartedEvent = new TargetStartedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile"); targetStartedEvent.BuildEventContext = context; NodeLoggingEvent targetStartedEventLoggingEvent = new NodeLoggingEvent(targetStartedEvent); targetStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); TargetFinishedEventArgs targetFinished = new TargetFinishedEventArgs("Message", "HelpKeyword","TargetName", "ProjectFile", "TargetFile", true); targetFinished.BuildEventContext = context; NodeLoggingEvent targetFinishedEventLoggingEvent = new NodeLoggingEvent(targetFinished); targetFinishedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); TaskStartedEventArgs taskStartedEvent = new TaskStartedEventArgs("Message", "HelpKeyword", "ProjectFile", "TaskFile", "TaskName"); taskStartedEvent.BuildEventContext = context; NodeLoggingEvent taskStartedEventLoggingEvent = new NodeLoggingEvent(taskStartedEvent); taskStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); TaskFinishedEventArgs taskFinishedEvent = new TaskFinishedEventArgs("Message", "HelpKeyword", "ProjectFile", "TaskFile", "TaskName", true); taskFinishedEvent.BuildEventContext = context; NodeLoggingEvent taskFinishedEventLoggingEvent = new NodeLoggingEvent(taskFinishedEvent); taskFinishedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); BuildFinishedEventArgs buildFinishedEvent = new BuildFinishedEventArgs("Message","Help",true); buildFinishedEvent.BuildEventContext = context; NodeLoggingEvent buildFinishedEventEventLoggingEvent = new NodeLoggingEvent(buildFinishedEvent); buildFinishedEventEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); BuildStartedEventArgs buildStartedEvent = new BuildStartedEventArgs("Message","Help"); buildStartedEvent.BuildEventContext = context; NodeLoggingEvent buildStartedEventLoggingEvent = new NodeLoggingEvent(buildStartedEvent); buildStartedEventLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); TaskCommandLineEventArgs commandlineEventArg = new TaskCommandLineEventArgs("CommandLine","TaskName", MessageImportance.High); commandlineEventArg.BuildEventContext = context; NodeLoggingEvent commandlineEventArgLoggingEvent = new NodeLoggingEvent(commandlineEventArg); commandlineEventArgLoggingEvent.WriteToStream(writer, loggingTypeCacheWrites); Hashtable loggingTypeCacheReads = new Hashtable(); long streamWriteEndPosition = stream.Position; stream.Position = 0; NodeLoggingEvent nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(GenericBuildEventArg)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(GenericCustomBuildEventArg)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildErrorEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildMessageEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildWarningEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(ProjectStartedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(ProjectFinishedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TargetStartedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TargetFinishedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TaskStartedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(TaskFinishedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildFinishedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() == typeof(BuildStartedEventArgs)); nodeLoggingEvent = new NodeLoggingEvent(null); nodeLoggingEvent.CreateFromStream(reader, loggingTypeCacheReads); Assert.IsTrue(nodeLoggingEvent.BuildEvent.GetType() ==typeof( TaskCommandLineEventArgs)); long streamReadEndPosition = stream.Position; Assert.AreEqual(streamWriteEndPosition, streamReadEndPosition, "Expected Read and Write Positions to match"); }
/// <summary> /// This is the delegate for TargetFinishedHandler events. /// </summary> private void TargetFinishedHandler(object sender, TargetFinishedEventArgs buildEvent) { --this.currentIndent; if ((isLogTaskDone) && LogAtImportance(buildEvent.Succeeded ? MessageImportance.Low : MessageImportance.High)) { LogEvent(sender, buildEvent); } }
/// <summary> /// Handler for target finished events /// </summary> /// <param name="sender">sender (should be null)</param> /// <param name="e">event arguments</param> public void TargetFinishedHandler(object sender, TargetFinishedEventArgs e) { InitializeBaseConsoleLogger(); // for compat: see DDB#136924 _consoleLogger.TargetFinishedHandler(sender, e); }
private void eventSource_TargetFinished(object sender, TargetFinishedEventArgs e) { if (stop) { return; } Execute(new BuildMessage(e)); if (stop) { KillThyself(); } }
public void TestTargetFinishedEventArgs() { // Test using reasonable values TargetFinishedEventArgs genericEvent = new TargetFinishedEventArgs("Message", "HelpKeyword", "TargetName", "ProjectFile", "TargetFile", true); genericEvent.BuildEventContext = new BuildEventContext(5, 4, 3, 2); // Serialize genericEvent.WriteToStream(_writer); long streamWriteEndPosition = _stream.Position; // Deserialize and Verify _stream.Position = 0; TargetFinishedEventArgs newGenericEvent = new TargetFinishedEventArgs(null, null, null, null, null, false); newGenericEvent.CreateFromStream(_reader, _eventArgVersion); long streamReadEndPosition = _stream.Position; Assert.IsTrue(streamWriteEndPosition == streamReadEndPosition, "Stream End Positions Should Match"); VerifyGenericEventArg(genericEvent, newGenericEvent); VerifyTargetFinished(genericEvent, newGenericEvent); // Test using empty strings _stream.Position = 0; genericEvent = new TargetFinishedEventArgs(string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, true); genericEvent.BuildEventContext = new BuildEventContext(5, 4, 3, 2); // Serialize genericEvent.WriteToStream(_writer); streamWriteEndPosition = _stream.Position; // Deserialize and Verify _stream.Position = 0; newGenericEvent = new TargetFinishedEventArgs(null, null, null, null, null, false); newGenericEvent.CreateFromStream(_reader, _eventArgVersion); streamReadEndPosition = _stream.Position; Assert.IsTrue(streamWriteEndPosition == streamReadEndPosition, "Stream End Positions Should Match"); VerifyGenericEventArg(genericEvent, newGenericEvent); VerifyTargetFinished(genericEvent, newGenericEvent); // Test using null strings _stream.Position = 0; // Make sure null string are passed correctly genericEvent = new TargetFinishedEventArgs(null, null, null, null, null, true); genericEvent.BuildEventContext = null; //Serialize genericEvent.WriteToStream(_writer); streamWriteEndPosition = _stream.Position; //Deserialize and Verify _stream.Position = 0; newGenericEvent = new TargetFinishedEventArgs("Something", "Something", "Something", "Something", "Something", false); newGenericEvent.CreateFromStream(_reader, _eventArgVersion); streamReadEndPosition = _stream.Position; Assert.IsTrue(streamWriteEndPosition == streamReadEndPosition, "Stream End Positions Should Match"); VerifyGenericEventArg(genericEvent, newGenericEvent); VerifyTargetFinished(genericEvent, newGenericEvent); }
/// <summary> /// Compare two TargetFinished events /// </summary> private static void VerifyTargetFinished(TargetFinishedEventArgs genericEvent, TargetFinishedEventArgs newGenericEvent) { Assert.IsTrue(genericEvent.Succeeded == newGenericEvent.Succeeded, "Expected Succeeded to Match"); Assert.IsTrue(string.Compare(genericEvent.ProjectFile, newGenericEvent.ProjectFile, StringComparison.OrdinalIgnoreCase) == 0, "Expected ProjectFile to Match"); Assert.IsTrue(string.Compare(genericEvent.TargetFile, newGenericEvent.TargetFile, StringComparison.OrdinalIgnoreCase) == 0, "Expected TargetFile to Match"); Assert.IsTrue(string.Compare(genericEvent.TargetName, newGenericEvent.TargetName, StringComparison.OrdinalIgnoreCase) == 0, "Expected TargetName to Match"); }
/// <summary> /// Handler for target finished events /// </summary> /// <param name="sender">sender (should be null)</param> /// <param name="e">event arguments</param> public override void TargetFinishedHandler(object sender, TargetFinishedEventArgs e) { // Done with the target, so shift everything left again. this.currentIndentLevel--; if (this.showPerfSummary) { PerformanceCounter counter = GetPerformanceCounter(e.TargetName, ref targetPerformanceCounters); // Place the counter "in scope" meaning the target is done executing right now. counter.InScope = false; } bool targetHasErrorsOrWarnings = contextStack.Peek().hasErrorsOrWarnings; // if verbosity is diagnostic, // or there was an error or warning and verbosity is normal or detailed if ((targetHasErrorsOrWarnings && (IsVerbosityAtLeast(LoggerVerbosity.Normal))) || Verbosity == LoggerVerbosity.Diagnostic) { setColor(ConsoleColor.Cyan); if (showTargetOutputs) { IEnumerable targetOutputs = e.TargetOutputs; if (targetOutputs != null) { WriteLinePretty(ResourceUtilities.FormatResourceString("TargetOutputItemsHeader")); foreach (ITaskItem item in targetOutputs) { WriteLinePretty(ResourceUtilities.FormatResourceString("TargetOutputItem", item.ItemSpec)); } } } WriteLinePretty(e.Message); resetColor(); } Frame top = contextStack.Pop(); this.VerifyStack(top.type == FrameType.Target, "bad stack frame type"); this.VerifyStack(top.ID == e.TargetName, "bad stack frame id"); // set the value on the Project frame, for the ProjectFinished handler if (targetHasErrorsOrWarnings) { SetErrorsOrWarningsOnCurrentFrame(); } }
void TargetFinished(object sender, TargetFinishedEventArgs e) { XmlElement targetElement = targetElements.Pop(); targetElements.Push(targetElement); targetElement.Attributes.Append(CreateFinishedAttribute(e.Timestamp)); targetElement.Attributes.Append(CreateAttribute("Succeeded", e.Succeeded.ToString())); if (base.IsVerbosityAtLeast(LoggerVerbosity.Detailed)) { targetElement.Attributes.Append(CreateAttribute("FinishMessage", e.Message)); } buildTypeList.Pop(); }
public TargetExecutionInfo(TargetStartedEventArgs startedArgs, TargetFinishedEventArgs finishedArgs) : this() { this.Name = startedArgs.TargetName; this.TimeSpent = finishedArgs.Timestamp.Subtract(startedArgs.Timestamp); }
private void OnTargetFinished(object sender, TargetFinishedEventArgs eventArgs) { }
/// <summary> /// Raises a "target build finished" event to all registered loggers. /// </summary> /// <param name="sender">sender of the event</param> /// <param name="buildEvent">TargetFinishedEventArgs</param> /// <exception cref="LoggerException">When EventHandler raises an logger exception the LoggerException is rethrown</exception> /// <exception cref="InternalLoggerException">Any exceptions which are not LoggerExceptions are wrapped in an InternalLoggerException</exception> /// <exception cref="Exception">ExceptionHandling.IsCriticalException exceptions will not be wrapped</exception> private void RaiseTargetFinishedEvent(object sender, TargetFinishedEventArgs buildEvent) { if (TargetFinished != null) { try { TargetFinished(sender, buildEvent); } 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.UnregisterAllEventHandlers(); 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.UnregisterAllEventHandlers(); if (ExceptionHandling.IsCriticalException(exception)) { throw; } InternalLoggerException.Throw(exception, buildEvent, "FatalErrorWhileLogging", false); } } RaiseStatusEvent(sender, buildEvent); }
public BuildMessage(TargetFinishedEventArgs args) { EventType = args.GetType().Name.Replace("EventArgs", ""); Message = args.Message; ProjectFile = args.ProjectFile; Succeeded = args.Succeeded; TargetFile = args.TargetFile; TargetName = args.TargetName; HelpKeyword = args.HelpKeyword; SenderName = args.SenderName; Timestamp = args.Timestamp; ThreadId = args.ThreadId; }
private void TargetFinished(object sender, TargetFinishedEventArgs e) { this.LogFinished(); }
/// <summary> /// Compare this build event context with another object to determine /// equality. This means the values inside the object are identical. /// </summary> /// <param name="obj">Object to compare to this object</param> /// <returns>True if the object values are identical, false if they are not identical</returns> public static bool IsEquivalent(TargetFinishedEventArgs args, TargetFinishedEventArgs other) { if (!String.Equals(args.ProjectFile, other.ProjectFile, StringComparison.OrdinalIgnoreCase)) { return false; } if (!String.Equals(args.TargetFile, other.TargetFile, StringComparison.OrdinalIgnoreCase)) { return false; } if (!String.Equals(args.TargetName, other.TargetName, StringComparison.OrdinalIgnoreCase)) { return false; } if (!Object.ReferenceEquals(args.TargetOutputs, other.TargetOutputs)) { // See if one is null, if so they are not equal if (args.TargetOutputs == null || other.TargetOutputs == null) { return false; } List<string> argItemIncludes = new List<string>(); foreach (TaskItem item in args.TargetOutputs) { argItemIncludes.Add(item.ToString()); } List<string> otherItemIncludes = new List<string>(); foreach (TaskItem item in other.TargetOutputs) { otherItemIncludes.Add(item.ToString()); } argItemIncludes.Sort(); otherItemIncludes.Sort(); if (argItemIncludes.Count != otherItemIncludes.Count) { return false; } // Since the lists are sorted each include must match for (int i = 0; i < argItemIncludes.Count; i++) { if (!argItemIncludes[i].Equals(otherItemIncludes[i], StringComparison.OrdinalIgnoreCase)) { return false; } } } return ((BuildEventArgs)args).IsEquivalent(other); }
private void TargetFinished(object sender, Microsoft.Build.Framework.TargetFinishedEventArgs e) { ChromeTracer.AddEndEvent(e.ThreadId, "Target:" + e.TargetName, GetTimeStamp(e.Timestamp), string.Empty); }
private void TargetFinished(object sender, TargetFinishedEventArgs e) { string line = string.Format(CultureInfo.InvariantCulture, "Done building target \"{0}\" in project \"{1}\"", e.TargetName, e.ProjectFile); this.indent--; this.WriteLine(line); }
/// <summary> /// Handle a target finished event /// </summary> /// <param name="sender">Who sent the event</param> /// <param name="e">Event raised on the event source</param> private void Source_TargetFinished(object sender, TargetFinishedEventArgs e) { HandleEvent(e); }
private void eventSource_TargetFinished(object sender, Microsoft.Build.Framework.TargetFinishedEventArgs e) { textBox.Text += Environment.NewLine + e.Message; }
void TargetFinished (object sender, TargetFinishedEventArgs args) { target_finished_events++; }
/// <summary> /// This is the delegate for TargetFinishedHandler events. /// </summary> private void TargetFinishedHandler(object sender, TargetFinishedEventArgs buildEvent) { try { --this.currentIndent; if ((isLogTaskDone) && LogAtImportance(buildEvent.Succeeded ? MessageImportance.Low : MessageImportance.High)) { LogEvent(sender, buildEvent); } } catch (Exception e) { Debug.Assert(false, "Problem logging targetfinished event: " + e.Message + " at " + e.TargetSite); // swallow the exception } }
void TargetFinished(object sender, TargetFinishedEventArgs e) { }
/// <summary> /// This is the delegate for TargetFinishedHandler events. /// </summary> protected virtual void TargetFinishedHandler(object sender, TargetFinishedEventArgs buildEvent) { // NOTE: This may run on a background thread! UnindentOutput(); QueueOutputEvent(MessageImportance.Low, buildEvent); }
public void TestMinimalWithNormalMessage() { for (int i = 1; i <= 2; i++) { EventSourceSink es = new EventSourceSink(); SimulatedConsole sc = new SimulatedConsole(); ConsoleLogger L = new ConsoleLogger(LoggerVerbosity.Minimal, sc.Write, sc.SetColor, sc.ResetColor); L.Initialize(es, i); BuildEventContext buildEventContext = new BuildEventContext(1, 2, 3, 4); BuildStartedEventArgs bse = new BuildStartedEventArgs("bs", null); bse.BuildEventContext = buildEventContext; es.Consume(bse); ProjectStartedEventArgs pse = new ProjectStartedEventArgs(1, "ps", null, "fname", "", null, null, new BuildEventContext(1, 1, 1, 1)); pse.BuildEventContext = buildEventContext; es.Consume(pse); TargetStartedEventArgs trse = new TargetStartedEventArgs("ts", null, "trname", "pfile", "tfile"); trse.BuildEventContext = buildEventContext; es.Consume(trse); TaskStartedEventArgs tase = new TaskStartedEventArgs("tks", null, "tname", "tfname", "tsname"); tase.BuildEventContext = buildEventContext; es.Consume(tase); BuildMessageEventArgs bmea = new BuildMessageEventArgs("foo!", null, "sender", MessageImportance.Normal); bmea.BuildEventContext = buildEventContext; es.Consume(bmea); TaskFinishedEventArgs tafea = new TaskFinishedEventArgs("tkf", null, "fname", "tsname", "tfname", true); tafea.BuildEventContext = buildEventContext; es.Consume(tafea); TargetFinishedEventArgs trfea = new TargetFinishedEventArgs("tf", null, "trname", "fname", "tfile", true); trfea.BuildEventContext = buildEventContext; es.Consume(trfea); ProjectFinishedEventArgs pfea = new ProjectFinishedEventArgs("pf", null, "fname", true); pfea.BuildEventContext = buildEventContext; es.Consume(pfea); BuildFinishedEventArgs bfea = new BuildFinishedEventArgs("bf", null, true); bfea.BuildEventContext = buildEventContext; es.Consume(bfea); Assert.AreEqual(String.Empty, sc.ToString()); } }