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