public void HandleBuildEvent(Microsoft.Build.Framework.BuildEventArgs e)
{
TaskStartedEventArgs start = e as TaskStartedEventArgs;
if (start != null && string.Equals(start.TaskName, desc.taskname, StringComparison.OrdinalIgnoreCase))
{
insideTask = true;
if (baseFilter == null)
{
IMSBuildLoggerFilter baseLoggerFilter = (IMSBuildLoggerFilter)desc.addIn.CreateObject(desc.classname);
if (baseLoggerFilter != null)
{
baseFilter = baseLoggerFilter.CreateFilter(context, nextFilter) ?? nextFilter;
}
else
{
baseFilter = nextFilter;
}
}
}
if (insideTask)
{
baseFilter.HandleBuildEvent(e);
}
else
{
nextFilter.HandleBuildEvent(e);
}
if (insideTask && e is TaskFinishedEventArgs)
{
insideTask = false;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Task"/> class.
/// </summary>
/// <param name="name">The name of the task.</param>
/// <param name="taskStartedEvent">The <see cref="TaskStartedEventArgs"/> instance containing the event data.</param>
/// <param name="assembly">The assembly from which the task originated.</param>
public Task(string name, TaskStartedEventArgs taskStartedEvent, string assembly)
{
Name = name;
Id = taskStartedEvent.BuildEventContext.TaskId;
StartTime = taskStartedEvent.Timestamp;
_fromAssembly = assembly;
}
public TaskStartedEventArgs AssertTaskExecuted(string taskName)
{
TaskStartedEventArgs found = this.executedTasks.FirstOrDefault(t => t.TaskName.Equals(taskName, StringComparison.InvariantCulture));
Assert.IsNotNull(found, "Specified task was not executed: {0}", taskName);
return(found);
}
/// <summary>
/// Logs that task execution has started.
/// </summary>
/// <param name="targetBuildEventContext">Event context for the target spawning this task.</param>
/// <param name="taskName">Task Name</param>
/// <param name="projectFile">Project file being built</param>
/// <param name="projectFileOfTaskNode">Project file which contains the task</param>
/// <param name="line">The line number in the file where the task invocation is located.</param>
/// <param name="column">The column number in the file where the task invocation is located.</param>
/// <returns>The build event context for the task.</returns>
/// <exception cref="InternalErrorException">BuildEventContext is null</exception>
public BuildEventContext LogTaskStarted2(BuildEventContext targetBuildEventContext, string taskName, string projectFile, string projectFileOfTaskNode, int line, int column)
{
lock (_lockObject)
{
ErrorUtilities.VerifyThrow(targetBuildEventContext != null, "targetBuildEventContext is null");
BuildEventContext taskBuildEventContext = new BuildEventContext
(
targetBuildEventContext.SubmissionId,
targetBuildEventContext.NodeId,
targetBuildEventContext.ProjectInstanceId,
targetBuildEventContext.ProjectContextId,
targetBuildEventContext.TargetId,
NextTaskId
);
if (!OnlyLogCriticalEvents)
{
TaskStartedEventArgs buildEvent = new TaskStartedEventArgs
(
message: null,
helpKeyword: null,
projectFile,
projectFileOfTaskNode,
taskName
);
buildEvent.BuildEventContext = taskBuildEventContext;
buildEvent.LineNumber = line;
buildEvent.ColumnNumber = column;
ProcessLoggingEvent(buildEvent);
}
return(taskBuildEventContext);
}
}
private void EventSource_TaskStarted(object sender, TaskStartedEventArgs e)
{
if (Verbosity >= LoggerVerbosity.Diagnostic)
{
HtmlQueue.Enqueue(new TaskStartedLogLine(e));
}
}
void TaskStarted(object sender, TaskStartedEventArgs e)
{
string indentStr = new string('\t', currentIndent++);
//AppendLine("TaskStarted: " + e.Message);
AppendLine(string.Format("{0}TaskStarted:{1}", indentStr, e.Message));
}
/// <summary>
/// Handles a TaskStarted event from the log. Creates the task and assigns to the appropriate target.
/// </summary>
/// <param name="taskStartedEventArgs">The <see cref="TaskStartedEventArgs"/> instance containing the event data.</param>
public void AddTask(TaskStartedEventArgs taskStartedEventArgs)
{
var project = GetOrAddProject(taskStartedEventArgs.BuildEventContext.ProjectContextId);
var target = project.GetTargetById(taskStartedEventArgs.BuildEventContext.TargetId);
target.AddChildTask(new Task(taskStartedEventArgs.TaskName, taskStartedEventArgs, GetTaskAssembly((taskStartedEventArgs.TaskName))));
}
private void EventSource_TaskStarted(object sender, TaskStartedEventArgs e)
{
if (TextBox != null)
{
//WriteLine(Environment.NewLine, e);
}
}
void OnTaskStarted(object sender, TaskStartedEventArgs args)
{
XmlElement e = StartElement("task", args);
AddAttribute(e, "name", args.TaskName);
AddAttribute(e, "file-id", ShortenFilePath(args.TaskFile));
}
private void OnTaskStarted(object sender, TaskStartedEventArgs e)
{
//Log.Trace($"Task '{e.TaskName}' Started");
//var sw = new Stopwatch();
//_taskTimes[e.TaskName] = sw;
//sw.Start();
}
void eventSource_TaskStarted(object sender, TaskStartedEventArgs e)
{
if (Verbosity > LoggerVerbosity.Normal)
{
output.AppendFormat("{0}" + Environment.NewLine, e.Message);
}
}
/// <summary>
/// Raises a "task execution started" event to all registered loggers.
/// </summary>
/// <param name="sender">sender of the event</param>
/// <param name="buildEvent">TaskStartedEventArgs</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 RaiseTaskStartedEvent(object sender, TaskStartedEventArgs buildEvent)
{
if (TaskStarted != null)
{
try
{
TaskStarted(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 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 Task CreateTask(TaskStartedEventArgs taskStartedEventArgs)
{
var taskName = stringTable.Intern(taskStartedEventArgs.TaskName);
var assembly = stringTable.Intern(GetTaskAssembly(taskName));
var taskId = taskStartedEventArgs.BuildEventContext.TaskId;
var startTime = taskStartedEventArgs.Timestamp;
Task result;
if (taskName == "Copy")
{
result = new CopyTask();
}
else
{
result = new Task();
}
result.Name = taskName;
result.Id = taskId;
result.NodeId = taskStartedEventArgs.BuildEventContext.NodeId;
result.StartTime = startTime;
result.FromAssembly = assembly;
result.SourceFilePath = stringTable.Intern(taskStartedEventArgs.TaskFile);
return(result);
}
protected override void OnStarted(TaskDelegateMetadata meta, TaskStartedEventArgs started)
{
if (meta.Started != null)
{
Dispatcher.Invoke(new Action(() => meta.Started(started)));
}
}
private Task CreateTask(TaskStartedEventArgs taskStartedEventArgs)
{
var taskName = Intern(taskStartedEventArgs.TaskName);
string assembly = null;
if (!IgnoreAssembly(taskName))
{
assembly = Intern(GetTaskAssembly(taskName));
}
var taskId = taskStartedEventArgs.BuildEventContext.TaskId;
var startTime = taskStartedEventArgs.Timestamp;
Task result = taskName.ToLowerInvariant() switch
{
"copy" => new CopyTask(),
"csc" => new CscTask(),
"vbc" => new VbcTask(),
"fsc" => new FscTask(),
"resolveassemblyreference" => new ResolveAssemblyReferenceTask(),
_ => new Task(),
};
result.Name = taskName;
result.Id = taskId;
result.NodeId = taskStartedEventArgs.BuildEventContext.NodeId;
result.StartTime = startTime;
result.FromAssembly = assembly;
result.SourceFilePath = Intern(taskStartedEventArgs.TaskFile);
return(result);
}
/// <summary>
/// Logs that task execution has started.
/// </summary>
/// <param name="targetBuildEventContext">Event context for the target spawning this task.</param>
/// <param name="taskName">Task Name</param>
/// <param name="projectFile">Project file being built</param>
/// <param name="projectFileOfTaskNode">Project file which contains the task</param>
/// <returns>The build event context for the task.</returns>
/// <exception cref="InternalErrorException">BuildEventContext is null</exception>
public BuildEventContext LogTaskStarted2(BuildEventContext targetBuildEventContext, string taskName, string projectFile, string projectFileOfTaskNode)
{
lock (_lockObject)
{
ErrorUtilities.VerifyThrow(targetBuildEventContext != null, "targetBuildEventContext is null");
BuildEventContext taskBuildEventContext = new BuildEventContext
(
targetBuildEventContext.SubmissionId,
targetBuildEventContext.NodeId,
targetBuildEventContext.ProjectInstanceId,
targetBuildEventContext.ProjectContextId,
targetBuildEventContext.TargetId,
NextTaskId
);
if (!OnlyLogCriticalEvents)
{
TaskStartedEventArgs buildEvent = new TaskStartedEventArgs
(
ResourceUtilities.FormatResourceStringIgnoreCodeAndKeyword("TaskStarted", taskName),
null, // no help keyword
projectFile,
projectFileOfTaskNode,
taskName
);
buildEvent.BuildEventContext = taskBuildEventContext;
ProcessLoggingEvent(buildEvent);
}
return(taskBuildEventContext);
}
}
void TaskStarted(object sender, TaskStartedEventArgs e)
{
if (IsVerbosityAtLeast(LoggerVerbosity.Detailed))
{
writer.WriteLine(GetLogMessage("TaskStarted", e));
}
}
private void OnTaskStarted(object sender, TaskStartedEventArgs e)
{
TaskViewModel taskViewModel = this.pendingTasks.FirstOrDefault(t => t.TaskId == e.TaskId);
if (taskViewModel == null)
{
return;
}
TaskProcessorViewModel processorViewModel = this.taskProcessors.FirstOrDefault(p => p.TaskProcessorId == e.TaskProcessorId);
if (processorViewModel == null)
{
return;
}
App.Current.Dispatcher.InvokeAsync(() =>
{
taskViewModel.Status = TaskStatus.InProgress.ToString();
taskViewModel.TaskProcessorId = e.TaskProcessorId;
taskViewModel.StartedUtc = e.TimestampUtc;
this.pendingTasks.Remove(taskViewModel);
processorViewModel.ActiveTasks.Add(taskViewModel);
});
}
/// <summary>
/// Handler for task started events
/// </summary>
/// <param name="sender">sender (should be null)</param>
/// <param name="e">event arguments</param>
private void TaskStartedHandler(object sender, TaskStartedEventArgs e)
{
if (forwardingTable[TaskStartedEventDescription] == 1)
{
ForwardToCentralLogger(e);
}
}
public void FireTaskStarted(object sender, TaskStartedEventArgs tsea)
{
if (taskStarted != null)
{
taskStarted(sender, tsea);
}
}
private Task CreateTask(TaskStartedEventArgs taskStartedEventArgs)
{
var taskName = stringTable.Intern(taskStartedEventArgs.TaskName);
var assembly = stringTable.Intern(GetTaskAssembly(taskStartedEventArgs.TaskName));
var taskId = taskStartedEventArgs.BuildEventContext.TaskId;
var startTime = taskStartedEventArgs.Timestamp;
Task result;
if (taskName == "Copy")
{
result = new CopyTask()
{
Name = taskName,
Id = taskId,
StartTime = startTime,
FromAssembly = assembly
};
return(result);
}
var task = new Task
{
Name = taskName,
Id = taskId,
StartTime = startTime,
FromAssembly = assembly
};
return(task);
}
// registered when only specific tasks should be forwarded
void OnTaskStarted(object sender, TaskStartedEventArgs e)
{
if (program.currentJob.InterestingTaskNames.Contains(e.TaskName))
{
OnEvent(sender, e);
}
}
internal PdbEntry TaskStarted(TaskStartedEventArgs e)
{
PdbEntry taskSymbol = null;
// We need to deal with 2 issues (a) batching (b) consecutive targets with same name (c) both
// We will make a compromise here - in case of (c), we will have one symbol for the 1st task
// and rest of symbols for the 2nd - irrespective of kind of combination we have for (c)
// i.e. 3M M or 2M 2M or M 3M are all treated as M 3M
string currentTaskName = projectStack.Peek().TargetStack.Peek().TargetSymbol.Children[projectStack.Peek().TargetStack.Peek().TaskNumber].Name;
if (!string.Equals(e.TaskName, currentTaskName, StringComparison.OrdinalIgnoreCase))
{
taskSymbol = projectStack.Peek().TargetStack.Peek().TargetSymbol.Children[++projectStack.Peek().TargetStack.Peek().TaskNumber];
}
else
{
string nextTaskName = (projectStack.Peek().TargetStack.Peek().TaskNumber < (projectStack.Peek().TargetStack.Peek().TargetSymbol.Children.Count - 1)) ?
projectStack.Peek().TargetStack.Peek().TargetSymbol.Children[projectStack.Peek().TargetStack.Peek().TaskNumber + 1].Name : null;
if (string.Equals(e.TaskName, nextTaskName, StringComparison.OrdinalIgnoreCase))
{
++projectStack.Peek().TargetStack.Peek().TaskNumber;
}
taskSymbol = projectStack.Peek().TargetStack.Peek().TargetSymbol.Children[projectStack.Peek().TargetStack.Peek().TaskNumber];
}
// Return the symbol
Debug.Assert(null != taskSymbol, "taskSymbol is null - this should never happen, we are going to crash!");
return(taskSymbol);
}
public void TaskStarted(object sender, TaskStartedEventArgs args)
{
try
{
lock (syncLock)
{
Build.Statistics.Tasks++;
var project = GetOrAddProject(args.BuildEventContext.ProjectContextId);
var target = project.GetTargetById(args.BuildEventContext.TargetId);
var task = CreateTask(args);
target.AddChild(task);
project.OnTaskAdded(task);
if (args is TaskStartedEventArgs2 taskStarted2)
{
task.LineNumber = taskStarted2.LineNumber;
}
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
internal void PopEvent <T> (T finished_args) where T : BuildStatusEventArgs
{
if (events.Count == 0)
{
throw new InvalidOperationException("INTERNAL ERROR: Trying to pop from an empty events stack");
}
BuildEvent be = events [events.Count - 1];
if (parent.config.PerformanceSummary || verbosity == LoggerVerbosity.Diagnostic)
{
var args = be.EventArgs;
TargetStartedEventArgs tgt_args = args as TargetStartedEventArgs;
if (tgt_args != null)
{
AddPerfInfo(tgt_args.TargetName, args.Timestamp, targetPerfTable);
}
else
{
TaskStartedEventArgs tsk_args = args as TaskStartedEventArgs;
if (tsk_args != null)
{
AddPerfInfo(tsk_args.TaskName, args.Timestamp, tasksPerfTable);
}
}
}
be.ExecuteFinishedHandler(finished_args);
events.RemoveAt(events.Count - 1);
current_events_string = null;
}
private void TaskStartedHandler(object sender, TaskStartedEventArgs buildEvent)
{
if (IfLog(MessageImportance.Normal))
{
Log(buildEvent);
}
++m_currentIndentation;
}
void LogTaskStarted()
{
TaskStartedEventArgs tsea = new TaskStartedEventArgs("Task started.", null,
parentTarget.Project.FullFileName,
parentTarget.TargetFile, taskElement.Name);
parentTarget.Project.ParentEngine.EventSource.FireTaskStarted(this, tsea);
}
private void Write(TaskStartedEventArgs e)
{
Write(BinaryLogRecordKind.TaskStarted);
WriteBuildEventArgsFields(e);
WriteOptionalString(e.TaskName);
WriteOptionalString(e.ProjectFile);
WriteOptionalString(e.TaskFile);
}
/// <summary>
/// This is the delegate for TaskStartedHandler events.
/// </summary>
private void TaskStartedHandler(object sender, TaskStartedEventArgs buildEvent)
{
if (LogAtImportance(MessageImportance.Normal))
{
LogEvent(sender, buildEvent);
}
++this.currentIndent;
}
private void eventSource_TaskStartedHandler(object sender, TaskStartedEventArgs e)
{
LogStageStarted(XmlLoggerElements.Task, e.TaskName, e.ProjectFile, e.Timestamp);
}
private void taskm_Started(object sender, TaskStartedEventArgs e)
{
RaiseCanExecuteChanged();
}
private void taskm_Started(object sender, TaskStartedEventArgs e)
{
logger.Log(string.Format(Resources.ReadStarted, GetMemoryType()), Category.Debug, Priority.None);
}
private void TaskStarted(object sender, TaskStartedEventArgs e)
{
SendMessage(FormatMessage(e));
}
private void taskm_Started(object sender, TaskStartedEventArgs e)
{
logger.Log(Resources.ReadLockStarted, Category.Debug, Priority.None);
}
