private void ProcessTaskStartEvent(TaskStartedEvent e, TimelineBuilderContext context)
{
Debug.Assert(context.HasOpenBuilds);
Debug.Assert(context.HasOpenProjects);
Debug.Assert(context.HasOpenTargets);
BuildEntry taskEntry = new BuildEntry(e);
context.OpenTaskEntries.Add(taskEntry);
// a task's parent is a Target
TaskEventContext taskContext = taskEntry.Context as TaskEventContext;
Debug.Assert(taskContext != null);
BuildEntry parentEntry = context.OpenTargetEntries.Find(targetEntry =>
{
TargetEventContext targetContext = targetEntry.Context as TargetEventContext;
Debug.Assert(targetContext != null);
return(targetContext.ContextId == taskContext.ContextId &&
targetContext.ProjectId == taskContext.ProjectId &&
targetContext.TargetId == taskContext.TargetId);
});
Debug.Assert(parentEntry != null);
parentEntry.AddChild(e);
parentEntry.AddChild(taskEntry);
}
private void ProcessProjectStartEvent(ProjectStartedEvent e, TimelineBuilderContext context)
{
Debug.Assert(context.HasOpenBuilds);
BuildEntry projectEntry = new BuildEntry(e);
context.OpenProjectEntries.Add(projectEntry);
// projects always have a parent, we know which via parent event context
BuildEntry parentEntry = null;
// no parent event context mean we've been spawned from the build itself
if (e.ParentEventContext == null)
{
parentEntry = context.RootEntry;
}
else
{
// a project's parent is a task, although the parent context refers to the task project's
parentEntry = context.OpenTaskEntries.Find(taskEntry =>
{
TaskEventContext taskContext = taskEntry.Context as TaskEventContext;
Debug.Assert(taskContext != null);
return(taskContext.ContextId == e.ParentEventContext.ContextId &&
taskContext.ProjectId == e.ParentEventContext.ProjectId);
});
// finding no task with matching data means our build was requested by a task that's already completed
// we may have some luck finding the project that spawned that task
if (parentEntry == null)
{
// our build couldn't be started before within the same node, hence it was scheduled
Debug.Assert(e.Context.NodeId != e.ParentEventContext.NodeId);
parentEntry = context.OpenProjectEntries.Find(otherProjectEntry =>
{
ProjectEventContext projectContext = otherProjectEntry.Context as ProjectEventContext;
Debug.Assert(projectContext != null);
return(projectContext.ContextId == e.ParentEventContext.ContextId &&
projectContext.ProjectId == e.ParentEventContext.ProjectId);
});
// the project may have also finished
if (parentEntry == null)
{
// just consider the build itself our parent
parentEntry = context.RootEntry;
}
}
}
Debug.Assert(parentEntry != null);
parentEntry.AddChild(e);
parentEntry.AddChild(projectEntry);
}
private TimelineBuilderContext ProcessEvents(List <Event> events)
{
TimelineBuilderContext context = new TimelineBuilderContext();
foreach (Event e in events)
{
if (e is BuildStartedEvent)
{
ProcessBuildStartEvent(e as BuildStartedEvent, context);
}
else if (e is BuildFinishedEvent)
{
ProcessBuildEndEvent(e as BuildFinishedEvent, context);
}
else if (e is ProjectStartedEvent)
{
ProcessProjectStartEvent(e as ProjectStartedEvent, context);
}
else if (e is ProjectFinishedEvent)
{
ProcessProjectEndEvent(e as ProjectFinishedEvent, context);
}
else if (e is TargetStartedEvent)
{
ProcessTargetStartEvent(e as TargetStartedEvent, context);
}
else if (e is TargetFinishedEvent)
{
ProcessTargetEndEvent(e as TargetFinishedEvent, context);
}
else if (e is TaskStartedEvent)
{
ProcessTaskStartEvent(e as TaskStartedEvent, context);
}
else if (e is TaskFinishedEvent)
{
ProcessTaskEndEvent(e as TaskFinishedEvent, context);
}
else if (e is MessageEvent)
{
ProcessMessageEvent(e as MessageEvent, context);
}
else if (e is WarningEvent)
{
ProcessMessageEvent(e as WarningEvent, context);
}
else if (e is ErrorEvent)
{
ProcessMessageEvent(e as ErrorEvent, context);
}
}
return(context);
}
private void ProcessProjectEndEvent(ProjectFinishedEvent e, TimelineBuilderContext context)
{
Debug.Assert(context.HasOpenBuilds);
BuildEntry projectEntry = context.OpenProjectEntries.Find(_ => _.Context.Equals(e.Context));
Debug.Assert(projectEntry != null);
projectEntry.Parent.AddChild(e);
projectEntry.CloseWith(e);
context.OpenProjectEntries.Remove(projectEntry);
}
private void ProcessBuildStartEvent(BuildStartedEvent e, TimelineBuilderContext context)
{
Debug.Assert(!context.HasOpenBuilds);
Debug.Assert(!context.HasOpenProjects);
Debug.Assert(!context.HasOpenTargets);
Debug.Assert(!context.HasOpenTasks);
Debug.Assert(context.RootEntry == null);
BuildEntry buildEntry = new BuildEntry(e);
context.OpenBuildEntries.Add(buildEntry);
context.RootEntry = buildEntry;
}
private void ProcessBuildEndEvent(BuildFinishedEvent e, TimelineBuilderContext context)
{
Debug.Assert(context.OpenBuildEntries.Count == 1);
Debug.Assert(!context.HasOpenProjects);
Debug.Assert(!context.HasOpenTargets);
Debug.Assert(!context.HasOpenTasks);
BuildEntry buildEntry = context.OpenBuildEntries[0];
Debug.Assert(buildEntry != null);
buildEntry.CloseWith(e);
context.OpenBuildEntries.Remove(buildEntry);
}
private Timeline BuildTimelineFrom(BuildData buildData, TimelineBuilderContext context)
{
Timeline timeline = new Timeline(buildData.BuildConfiguration.MaxParallelProjects);
// build belongs to NodeId 0, as reported by MSBuild, while other entries start at NodeId 1
Debug.Assert(context.RootEntry.Context == null);
TimelineBuildEntry topLevelTimelineBuildEntry = new TimelineBuildEntry(context.RootEntry, buildData);
timeline.AddRoot(topLevelTimelineBuildEntry);
// process other entries
BuildTimelineEntries(timeline, topLevelTimelineBuildEntry, buildData);
return(timeline);
}
public Timeline Build(TimelineEntryPostProcessor.Processor perEntryPostProcessors)
{
TimelineBuilderContext context = ProcessEvents(m_buildData.Events);
Debug.Assert(!context.HasOpenBuilds);
Debug.Assert(!context.HasOpenProjects);
Debug.Assert(!context.HasOpenTargets);
Debug.Assert(!context.HasOpenTasks);
Debug.Assert(context.RootEntry != null);
Timeline timeline = BuildTimelineFrom(m_buildData, context);
if (perEntryPostProcessors != null)
{
PostProcess(timeline, perEntryPostProcessors);
}
CalculateParallelEntries(timeline);
EnsureNoEntryOverflowsParent(timeline);
return(timeline);
}
private void ProcessMessageEvent(MessageEvent e, TimelineBuilderContext context)
{
Debug.Assert(context.HasOpenBuilds);
// a message can be executed as part of any entry: build, project, target or task
BuildEntry parentEntry = null;
// part of the build?
if (e.Context == null)
{
parentEntry = context.RootEntry;
}
else
{
MessageEventContext messageContext = e.Context as MessageEventContext;
// part of a task?
if (messageContext.TaskId != null)
{
Debug.Assert(messageContext.ProjectId != null);
Debug.Assert(messageContext.TargetId != null);
parentEntry = context.OpenTaskEntries.Find(taskEntry =>
{
TaskEventContext taskContext = taskEntry.Context as TaskEventContext;
Debug.Assert(taskContext != null);
return(taskContext.NodeId == messageContext.NodeId &&
taskContext.ContextId == messageContext.ContextId &&
taskContext.ProjectId == messageContext.ProjectId &&
taskContext.TargetId == messageContext.TargetId &&
taskContext.TaskId == messageContext.TaskId);
});
}
// part of a target?
else if (messageContext.TargetId != null)
{
Debug.Assert(messageContext.ProjectId != null);
Debug.Assert(messageContext.TaskId == null);
parentEntry = context.OpenTargetEntries.Find(targetEntry =>
{
TargetEventContext targetContext = targetEntry.Context as TargetEventContext;
Debug.Assert(targetContext != null);
return(targetContext.NodeId == messageContext.NodeId &&
targetContext.ContextId == messageContext.ContextId &&
targetContext.ProjectId == messageContext.ProjectId &&
targetContext.TargetId == messageContext.TargetId);
});
}
// part of a project?
else if (messageContext.ProjectId != null)
{
Debug.Assert(messageContext.TargetId == null);
Debug.Assert(messageContext.TaskId == null);
parentEntry = context.OpenProjectEntries.Find(projectEntry =>
{
ProjectEventContext projectContext = projectEntry.Context as ProjectEventContext;
Debug.Assert(projectContext != null);
return(projectContext.NodeId == messageContext.NodeId &&
projectContext.ContextId == messageContext.ContextId &&
projectContext.ProjectId == messageContext.ProjectId);
});
}
// part of the build itself?
else
{
parentEntry = context.RootEntry;
}
}
Debug.Assert(parentEntry != null);
parentEntry.AddChild(e);
}
