private Target GetTarget(BuildEventContext buildEventContext)
        {
            var project = construction.GetOrAddProject(buildEventContext.ProjectContextId);

            if (project == null)
            {
                return(null);
            }

            var target = project.GetTargetById(buildEventContext.TargetId);

            return(target);
        }
示例#2
0
        private Task GetTask(BuildMessageEventArgs args)
        {
            var project = construction.GetOrAddProject(args.BuildEventContext.ProjectContextId);
            var target  = project.GetTargetById(args.BuildEventContext.TargetId);
            var task    = target.GetTaskById(args.BuildEventContext.TaskId);

            return(task);
        }
        /// <summary>
        /// Handles a generic BuildMessage event and assigns it to the appropriate logging node.
        /// </summary>
        /// <param name="args">The <see cref="BuildMessageEventArgs"/> instance containing the event data.</param>
        public void AddMessage(LazyFormattedBuildEventArgs args, string message)
        {
            TreeNode parent       = null;
            BaseNode nodeToAdd    = null;
            bool     lowRelevance = false;

            var buildEventContext = args.BuildEventContext;

            if (buildEventContext.TaskId > 0)
            {
                parent = GetTask(args);
                if (parent is Task task)
                {
                    if (task is ResolveAssemblyReferenceTask rar)
                    {
                        if (ProcessRAR(rar, ref parent, message))
                        {
                            return;
                        }
                    }
                    else if (string.Equals(task.Name, "MSBuild", StringComparison.OrdinalIgnoreCase))
                    {
                        if (ProcessMSBuildTask(task, ref parent, ref nodeToAdd, message))
                        {
                            return;
                        }
                    }
                    else if (string.Equals(task.Name, "RestoreTask", StringComparison.OrdinalIgnoreCase))
                    {
                        if (ProcessRestoreTask(task, ref parent, message))
                        {
                            return;
                        }
                    }
                    else if (string.Equals(task.Name, "Mmp", StringComparison.OrdinalIgnoreCase))
                    {
                        if (ProcessMmp(task, ref parent, message))
                        {
                            return;
                        }
                    }
                }
            }
            else if (buildEventContext.TargetId > 0)
            {
                parent = GetTarget(args);

                if (Strings.TaskSkippedFalseConditionRegex.IsMatch(message))
                {
                    lowRelevance = true;
                }
            }
            else if (buildEventContext.ProjectContextId > 0)
            {
                var project = construction.GetOrAddProject(buildEventContext.ProjectContextId);
                parent = project;

                if (message.Equals("Building with tools version \"Current\".", StringComparison.Ordinal))
                {
                    // this is useless so just drop it on the floor
                    return;
                }

                if (Strings.IsTargetSkipped(message))
                {
                    var targetName = Intern(TextUtilities.ParseQuotedSubstring(message));
                    if (targetName != null)
                    {
                        var skippedTarget = project.GetOrAddTargetByName(targetName, args.Timestamp);
                        skippedTarget.StartTime = args.Timestamp;
                        skippedTarget.EndTime   = args.Timestamp;
                        parent       = skippedTarget;
                        lowRelevance = true;
                    }
                }
            }
            else if (buildEventContext.EvaluationId != -1)
            {
                parent = construction.EvaluationFolder;

                var evaluationId = buildEventContext.EvaluationId;
                var evaluation   = construction.Build.FindEvaluation(evaluationId);
                if (evaluation != null)
                {
                    parent = evaluation;
                }

                if (args is PropertyReassignmentEventArgs || Strings.PropertyReassignmentRegex.IsMatch(message))
                {
                    TimedNode properties;
                    if (evaluation != null)
                    {
                        properties = evaluation.PropertyReassignmentFolder;
                    }
                    else
                    {
                        properties = parent.GetOrCreateNodeWithName <TimedNode>(Strings.PropertyReassignmentFolder, addAtBeginning: true);
                    }

                    var propertyName = Strings.GetPropertyName(message);
                    parent = properties.GetOrCreateNodeWithName <Folder>(propertyName);
                }
                else if (parent == evaluation && parent.FindChild <Message>(message) != null)
                {
                    // avoid duplicate messages
                    return;
                }
            }

            if (parent == null)
            {
                parent = construction.Build;

                if (construction.Build.FileFormatVersion < 9 && Strings.IsEvaluationMessage(message))
                {
                    if (!evaluationMessagesAlreadySeen.Add(message))
                    {
                        return;
                    }

                    parent = construction.EvaluationFolder;
                }
                else if (construction.Build.FileFormatVersion < 9 && Strings.PropertyReassignmentRegex.IsMatch(message))
                {
                    if (!evaluationMessagesAlreadySeen.Add(message))
                    {
                        return;
                    }

                    var properties = construction.EvaluationFolder.GetOrCreateNodeWithName <Folder>(Strings.PropertyReassignmentFolder);
                    parent = properties.GetOrCreateNodeWithName <Folder>(Strings.GetPropertyName(message));
                }
                else if (Strings.IsTargetDoesNotExistAndWillBeSkipped(message))
                {
                    var folder = construction.EvaluationFolder;
                    parent       = folder;
                    lowRelevance = true;
                }
                else if (
                    buildEventContext.NodeId == 0 &&
                    buildEventContext.ProjectContextId == 0 &&
                    buildEventContext.ProjectInstanceId == 0 &&
                    buildEventContext.TargetId == 0 &&
                    buildEventContext.TaskId == 0)
                {
                    // must be Detailed Build Summary
                    // https://github.com/Microsoft/msbuild/blob/master/src/XMakeBuildEngine/BackEnd/Components/Scheduler/Scheduler.cs#L509
                    DetailedSummary.AppendLine(message);
                    return;
                }
                else if (
                    buildEventContext.NodeId == -2 &&
                    buildEventContext.ProjectContextId == -2 &&
                    buildEventContext.ProjectInstanceId == -1)
                {
                    if (message.StartsWith(Strings.MSBuildVersionPrefix))
                    {
                        var version = message.Substring(Strings.MSBuildVersionPrefix.Length);
                        construction.Build.MSBuildVersion = version;
                    }
                }
            }

            if (nodeToAdd == null)
            {
                message   = Intern(message);
                nodeToAdd = new Message
                {
                    Text           = message,
                    Timestamp      = args.Timestamp,
                    IsLowRelevance = lowRelevance
                };
            }

            parent.AddChild(nodeToAdd);
        }