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);
}
void BuildStarted(object sender, BuildStartedEventArgs e)
{
_stopwatch = Stopwatch.StartNew();
Console.WriteLine("Initializing the compilation.");
Console.WriteLine();
Console.WriteLine();
}
public void EventArgsCtors()
{
BuildStartedEventArgs bsea = new BuildStartedEventArgs2();
bsea = new BuildStartedEventArgs("Message", "HelpKeyword");
bsea = new BuildStartedEventArgs("Message", "HelpKeyword", DateTime.Now);
bsea = new BuildStartedEventArgs("{0}", "HelpKeyword", DateTime.Now, "Message");
bsea = new BuildStartedEventArgs(null, null);
bsea = new BuildStartedEventArgs(null, null, DateTime.Now);
bsea = new BuildStartedEventArgs(null, null, DateTime.Now, null);
}
public void AssignmentTest ()
{
BuildStartedEventArgs bsea;
string message = "message";
string helpKeyword = "helpKeyword";
bsea = new BuildStartedEventArgs (message, helpKeyword);
Assert.AreEqual (message, bsea.Message, "Message");
Assert.AreEqual (helpKeyword, bsea.HelpKeyword, "HelpKeyword");
}
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");
}
public BuildMessage(BuildStartedEventArgs args)
{
EventType = args.GetType().Name.Replace("EventArgs", "");
Message = args.Message;
HelpKeyword = args.HelpKeyword;
SenderName = args.SenderName;
Timestamp = args.Timestamp;
ThreadId = args.ThreadId;
}
private void eventSource_BuildStarted(object sender, BuildStartedEventArgs e)
{
if (stop) {
return;
}
Execute(new BuildMessage(e));
if (stop) {
KillThyself();
}
}
public abstract void BuildStartedHandler(object sender, BuildStartedEventArgs e);
void BuildStarted(object sender, BuildStartedEventArgs e)
{
buildTypeList.Push(BuildType.Build);
XmlElement buildElement = xmlDoc.CreateElement("Build");
rootElement.AppendChild(buildElement);
buildElement.Attributes.Append(
CreateStartedAttribute(e.Timestamp));
buildElement.Attributes.Append(
CreateAttribute("Verbosity", this.Verbosity.ToString()));
if (this.Parameters != null &&
base.IsVerbosityAtLeast(LoggerVerbosity.Detailed))
{
//log all the parameters that were passed to the logger
XmlElement paramElement =
xmlDoc.CreateElement("LoggerParameters");
buildElement.AppendChild(paramElement);
foreach (string current in DefiniedParameters)
{
XmlElement currentElement =
xmlDoc.CreateElement("Parameter");
currentElement.InnerText =
current + "=" + GetParameterValue(current);
paramElement.AppendChild(currentElement);
}
}
buildElement.AppendChild(CreateMessageElement(e.Message));
buildElements.Push(buildElement);
}
public void ForwardEvents()
{
BuildStartedEventArgs buildStarted = new BuildStartedEventArgs("Message", "Help");
BuildFinishedEventArgs buildFinished = new BuildFinishedEventArgs("Message", "Keyword", true);
BuildMessageEventArgs normalMessage = new BuildMessageEventArgs("Message2", "help", "sender", MessageImportance.Normal);
EventSourceSink loggerSource = AttachForwardingLoggerAndRedirector(buildStarted);
loggerSource.Consume(buildStarted);
loggerSource = AttachForwardingLoggerAndRedirector(buildFinished);
loggerSource.Consume(buildFinished);
loggerSource = AttachForwardingLoggerAndRedirector(normalMessage);
loggerSource.Consume(normalMessage);
}
void OnBuildStarted(object sender, BuildStartedEventArgs e)
{
TraceSource.TraceInformation(e.Message);
}
/// <summary>
/// Note with msbuild:
/// Be careful - the onBuildStarted(i.e. all before onTargetStarted) is not safe for any unhandled exceptions!
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void onBuildStarted(object sender, BuildStartedEventArgs e)
{
try {
// load with properties by default
library = initializer.load();
attachCoreCommandListener();
library.Event.solutionOpened(pUnkReserved, 0);
// yes, we're ready
onPre(initializer.Properties.Targets);
}
catch(Exception ex) {
debug("Error onBuildStarted: '{0}'", ex.Message);
abort = true;
}
}
/// <summary>
/// Handles the BuildStarted event.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The <see cref="BuildStartedEventArgs" /> instance containing the event data.</param>
/// <exception cref="System.NotImplementedException"></exception>
private void BuildStartedEventHandler(object sender, BuildStartedEventArgs e)
{
_buildStartedTimeStamp = DateTime.Now;
}
/// <summary>
/// Raises a "build started" event to all registered loggers.
/// </summary>
/// <param name="sender">sender of the event</param>
/// <param name="buildEvent">BuildStartedEventArgs</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 RaiseBuildStartedEvent(object sender, BuildStartedEventArgs buildEvent)
{
if (BuildStarted != null)
{
try
{
BuildStarted(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);
}
private void BuildStarted(object sender, BuildStartedEventArgs e)
{
this.startTime = DateTime.UtcNow;
this.LogStarted("build", string.Empty, string.Empty);
}
/// <summary>
/// Handler for build started events
/// </summary>
/// <param name="sender">sender (should be null)</param>
/// <param name="e">event arguments</param>
public void BuildStartedHandler(object sender, BuildStartedEventArgs e)
{
InitializeBaseConsoleLogger(); // for compat: see DDB#136924
_consoleLogger.BuildStartedHandler(sender, e);
}
/// <summary>
/// This is the delegate for BuildStartedHandler events.
/// </summary>
protected override void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
base.BuildStartedHandler(sender, buildEvent);
_timer = Stopwatch.StartNew();
}
/// <summary>
/// Handler for build started events
/// </summary>
/// <param name="sender">sender (should be null)</param>
/// <param name="e">event arguments</param>
public override void BuildStartedHandler(object sender, BuildStartedEventArgs e)
{
buildStarted = e.Timestamp;
// if verbosity is detailed or diagnostic
if (IsVerbosityAtLeast(LoggerVerbosity.Normal))
{
WriteLinePrettyFromResource("BuildStartedWithTime", e.Timestamp);
}
WriteEnvironment(e.BuildEnvironment);
}
private void BuildStarted(object sender, BuildStartedEventArgs e)
{
this.startTime = DateTime.UtcNow;
string line = string.Format(CultureInfo.InvariantCulture, "{0} {1}", e.Message, e.Timestamp);
this.WriteLine(line);
this.WriteLine("__________________________________________________");
}
/// <summary>
/// Handle a build started event
/// </summary>
/// <param name="sender">Who sent the event</param>
/// <param name="e">Event raised on the event source</param>
private void Source_BuildStarted(object sender, BuildStartedEventArgs e)
{
HandleEvent(e);
}
/// <summary>
/// This is the delegate for BuildStartedHandler events.
/// </summary>
private void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
if (LogAtImportance(MessageImportance.Low))
{
LogEvent(sender, buildEvent);
}
// Remove all errors and warnings since we are rebuilding
taskProvider.Tasks.Clear();
}
void LogBuildStarted()
{
BuildStartedEventArgs bsea;
bsea = new BuildStartedEventArgs ("Build started.", null);
eventSource.FireBuildStarted (this, bsea);
}
void HandleBuildStarted (object sender, BuildStartedEventArgs args)
{
CreateWriter (true);
}
/// <summary>
/// This is the delegate for BuildStartedHandler events.
/// </summary>
protected virtual void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
// NOTE: This may run on a background thread!
ClearCachedVerbosity();
ClearQueuedOutput();
ClearQueuedTasks();
QueueOutputEvent(MessageImportance.Low, buildEvent);
}
private void eventSource_BuildStarted(object sender, Microsoft.Build.Framework.BuildStartedEventArgs e)
{
errorsCount = 0;
warningsCount = 0;
textBox.Text = e.Message;
}
private void eventSource_BuildStarted(object sender, Microsoft.Build.Framework.BuildStartedEventArgs e)
{
errorsCount = 0;
warningsCount = 0;
this.AddNode(String.Format("{0} {1}", e.Message, e.Timestamp.ToString()));
}
/// <summary>
/// This is the delegate for BuildStartedHandler events.
/// </summary>
private void BuildStartedHandler(object sender, BuildStartedEventArgs buildEvent)
{
try
{
this.haveCachedRegistry = false;
if (LogAtImportance(MessageImportance.Low))
{
LogEvent(sender, buildEvent);
}
}
catch (Exception e)
{
Debug.Assert(false, "Problem logging buildstarted event: " + e.Message + " at " + e.TargetSite);
// swallow the exception
}
finally
{
// remove all Project System tasks from the task list, add everything else to the task set
taskReporter.ClearAllTasks();
}
}
void BuildStarted(object sender, BuildStartedEventArgs e)
{
AppendLine(string.Format("#Build Started {0}",e.Timestamp));
var r = from be in e.BuildEnvironment.Keys
select new {
Name = be,
Value = e.BuildEnvironment[be]
};
AppendLine(r.ToMarkdownTable().ToMarkdown());
if (IsVerbosityAtLeast(LoggerVerbosity.Detailed)) {
AppendLine(e.ToPropertyValues().ToMarkdownTable().ToMarkdown());
}
}
private void eventSource_BuildStartedHandler(object sender, BuildStartedEventArgs e)
{
LogStageStarted(XmlLoggerElements.Build, "", "", e.Timestamp);
}
void BuildStarted(object sender, BuildStartedEventArgs e)
{
}
void BuildStarted(object sender, BuildStartedEventArgs e)
{
Console.WriteLine("Sublime Text 2 output logger by Jacob Pennock, Updated by Frédéric Vauchelles");
}
private void OnBuildStarted(object sender, BuildStartedEventArgs eventArgs)
{
}