/// <summary>
/// Initializes a new instance of the <see cref="TaskParameter"/> class.
/// </summary>
/// <param name="message">The message from the logging system.</param>
/// <param name="prefix">The prefix parsed out (e.g. 'Output Item(s): ').</param>
/// <param name="collapseSingleItem">If set to <c>true</c>, will collapse the node to a single item when possible.</param>
/// <param name="itemAttributeName">Name of the item 'Include' attribute.</param>
protected TaskParameter(string message, string prefix, bool collapseSingleItem = true, string itemAttributeName = "Include")
{
this.collapseSingleItem = collapseSingleItem;
this.itemAttributeName = itemAttributeName;
foreach (var item in ItemGroupParser.ParseItemList(message, prefix, out name))
{
items.Add(item);
}
}
/// <summary>
/// Handles BuildMessage event when an ItemGroup discovery/evaluation is logged.
/// </summary>
/// <param name="args">The <see cref="BuildMessageEventArgs"/> instance containing the event data.</param>
/// <param name="prefix">The prefix string.</param>
public void AddItemGroup(BuildMessageEventArgs args, string prefix, NamedNode containerNode)
{
var project = construction.GetOrAddProject(args.BuildEventContext.ProjectContextId);
var target = project.GetTargetById(args.BuildEventContext.TargetId);
var itemGroup = ItemGroupParser.ParsePropertyOrItemList(args.Message, prefix, stringTable);
var property = itemGroup as Property;
if (property != null)
{
itemGroup = new Item
{
Name = property.Name,
Text = property.Value
};
containerNode.Name = stringTable.Intern(property.Name);
}
containerNode.AddChild(itemGroup);
target.AddChild(containerNode);
}
/// <summary>
/// Handles BuildMessage event when an ItemGroup discovery/evaluation is logged.
/// </summary>
/// <param name="args">The <see cref="BuildMessageEventArgs"/> instance containing the event data.</param>
/// <param name="prefix">The prefix string.</param>
public void AddItemGroup(BuildMessageEventArgs args, string prefix, NamedNode containerNode)
{
var project = construction.GetOrAddProject(args.BuildEventContext.ProjectContextId);
var target = project.GetTargetById(args.BuildEventContext.TargetId);
var itemGroup = ItemGroupParser.ParsePropertyOrItemList(args.Message, prefix, stringTable);
if (itemGroup is Property property)
{
itemGroup = new Item
{
Text = property.Value
};
containerNode.Name = property.Name;
containerNode.AddChild(itemGroup);
}
else if (itemGroup is Parameter parameter)
{
containerNode.Name = parameter.Name;
foreach (ParentedNode child in parameter.Children)
{
child.Parent = null;
containerNode.AddChild(child);
}
}
if (target.LastChild is NamedNode last &&
last.GetType() == containerNode.GetType() &&
last.Name == containerNode.Name)
{
foreach (ParentedNode child in containerNode.Children)
{
child.Parent = null;
last.AddChild(child);
}
return;
}
target.AddChild(containerNode);
}
public void WarningRaised(object sender, BuildWarningEventArgs args)
{
try
{
lock (syncLock)
{
TreeNode parent = FindParent(args.BuildEventContext);
if (parent == null)
{
parent = Build;
}
var warning = new Warning();
string text = args.Message;
if (parent is ResolveAssemblyReferenceTask rar)
{
var match = Strings.IsFoundConflicts(text);
if (match.Success)
{
string details = match.Groups[2].Value;
// https://github.com/KirillOsenkov/MSBuildStructuredLog/issues/443
ItemGroupParser.ParseThereWasAConflict(warning, details, stringTable);
text = text.GetFirstLine();
}
}
parent = parent.GetOrCreateNodeWithName <Folder>(Strings.Warnings);
Populate(warning, args, text);
parent.AddChild(warning);
}
}
catch (Exception ex)
{
HandleException(ex);
}
}
public void Process(BuildMessageEventArgs args)
{
if (args == null)
{
return;
}
var message = args.Message;
if (string.IsNullOrEmpty(message))
{
return;
}
switch (message[0])
{
case 'A':
if (message.StartsWith(ItemGroupIncludeMessagePrefix))
{
AddItemGroup(args, ItemGroupIncludeMessagePrefix, new AddItem());
return;
}
break;
case 'O':
if (message.StartsWith(OutputItemsMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputItems");
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, OutputItemsMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
if (message.StartsWith(OutputPropertyMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputProperties");
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, OutputPropertyMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
break;
case 'R':
if (message.StartsWith(ItemGroupRemoveMessagePrefix))
{
AddItemGroup(args, ItemGroupRemoveMessagePrefix, new RemoveItem());
return;
}
break;
case 'S':
if (message.StartsWith(PropertyGroupMessagePrefix))
{
AddPropertyGroup(args, PropertyGroupMessagePrefix);
return;
}
break;
case 'T':
if (message.StartsWith(TaskParameterMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("Parameters");
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, TaskParameterMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
break;
case 'U':
// A task from assembly message (parses out the task name and assembly path).
var match = usingTaskRegex.Match(message);
if (match.Success)
{
construction.SetTaskAssembly(
stringTable.Intern(match.Groups["task"].Value),
stringTable.Intern(match.Groups["assembly"].Value));
return;
}
break;
default:
break;
}
if (args is TaskCommandLineEventArgs taskArgs)
{
AddCommandLine(taskArgs);
return;
}
// Just the generic log message or something we currently don't handle in the object model.
AddMessage(args, message);
}
public void Process(BuildMessageEventArgs args)
{
if (args == null)
{
return;
}
var message = args.Message;
if (string.IsNullOrEmpty(message))
{
return;
}
if (args.SenderName == "BinaryLogger")
{
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, string.Empty, stringTable);
construction.Build.AddChild(parameter);
return;
}
if (message.StartsWith(Strings.ItemGroupIncludeMessagePrefix))
{
AddItemGroup(args, Strings.ItemGroupIncludeMessagePrefix, new AddItem());
return;
}
if (message.StartsWith(Strings.OutputItemsMessagePrefix))
{
var task = GetTask(args);
//this.construction.Build.Statistics.ReportOutputItemMessage(task, message);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputItems");
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.OutputItemsMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
if (message.StartsWith(Strings.OutputPropertyMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputProperties");
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.OutputPropertyMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
if (message.StartsWith(Strings.ItemGroupRemoveMessagePrefix))
{
AddItemGroup(args, Strings.ItemGroupRemoveMessagePrefix, new RemoveItem());
return;
}
if (message.StartsWith(Strings.PropertyGroupMessagePrefix))
{
AddPropertyGroup(args, Strings.PropertyGroupMessagePrefix);
return;
}
if (message.StartsWith(Strings.TaskParameterMessagePrefix))
{
var task = GetTask(args);
if (IgnoreParameters(task))
{
return;
}
//this.construction.Build.Statistics.ReportTaskParameterMessage(task, message);
var folder = task.GetOrCreateNodeWithName <Folder>(Strings.Parameters);
var parameter = ItemGroupParser.ParsePropertyOrItemList(message, Strings.TaskParameterMessagePrefix, stringTable);
folder.AddChild(parameter);
return;
}
// A task from assembly message (parses out the task name and assembly path).
var match = Strings.UsingTask(message);
if (match.Success)
{
construction.SetTaskAssembly(
stringTable.Intern(match.Groups["task"].Value),
stringTable.Intern(match.Groups["assembly"].Value));
return;
}
if (args is TaskCommandLineEventArgs taskArgs)
{
if (AddCommandLine(taskArgs))
{
return;
}
}
// Just the generic log message or something we currently don't handle in the object model.
AddMessage(args, message);
}
private bool ProcessRAR(ResolveAssemblyReferenceTask task, ref TreeNode node, string message)
{
Folder inputs = task.Inputs;
Folder results = task.Results;
node = results ?? inputs;
if (message.StartsWith(" ", StringComparison.Ordinal))
{
message = message.Substring(4);
var parameter = node?.FindLastChild <Parameter>();
if (parameter != null)
{
bool thereWasAConflict = Strings.IsThereWasAConflictPrefix(parameter.Name);
if (thereWasAConflict)
{
if (construction.Build.IsMSBuildVersionAtLeast(16, 9))
{
// https://github.com/KirillOsenkov/MSBuildStructuredLog/issues/443
ItemGroupParser.ParseThereWasAConflict(parameter, message, stringTable);
}
else
{
HandleThereWasAConflict(parameter, message, stringTable);
}
return(true);
}
if (!string.IsNullOrWhiteSpace(message))
{
node = parameter;
if (message.StartsWith(" ", StringComparison.Ordinal))
{
message = message.Substring(4);
var lastItem = parameter.FindLastChild <Item>();
// only indent if it's not a "For SearchPath..." message - that one needs to be directly under parameter
// also don't indent if it's under AssemblyFoldersEx in Results
if (lastItem != null &&
!Strings.ForSearchPathPrefix.IsMatch(message) &&
!parameter.Name.StartsWith("AssemblyFoldersEx", StringComparison.Ordinal))
{
node = lastItem;
}
}
if (!string.IsNullOrEmpty(message))
{
var equals = message.IndexOf('=');
if (equals != -1 && message.IndexOfFirstLineBreak() == -1)
{
var kvp = TextUtilities.ParseNameValue(message);
var metadata = new Metadata
{
Name = Intern(kvp.Key.TrimEnd(space)),
Value = Intern(kvp.Value.TrimStart(space))
};
node.Children.Add(metadata);
metadata.Parent = node;
}
else
{
node.AddChild(new Item
{
Text = Intern(message)
});
}
}
}
return(true);
}
}
else
{
if (results == null)
{
bool isResult = Strings.UnifiedPrimaryReferencePrefix.IsMatch(message) ||
Strings.PrimaryReferencePrefix.IsMatch(message) ||
Strings.DependencyPrefix.IsMatch(message) ||
Strings.UnifiedDependencyPrefix.IsMatch(message) ||
Strings.AssemblyFoldersExLocation.IsMatch(message) ||
Strings.IsThereWasAConflictPrefix(message);
if (isResult)
{
results = task.GetOrCreateNodeWithName <Folder>(Strings.Results);
task.Results = results;
node = results;
}
else
{
if (inputs == null)
{
inputs = task.GetOrCreateNodeWithName <Folder>(Strings.Inputs);
task.Inputs = inputs;
}
node = inputs;
}
}
else
{
node = results;
}
var parameter = new Parameter();
string parameterName;
if (Strings.IsThereWasAConflictPrefix(message))
{
ItemGroupParser.ParseThereWasAConflict(parameter, message, stringTable);
parameterName = message.GetFirstLine();
}
else
{
parameterName = message.TrimEnd(':');
}
parameter.Name = Intern(parameterName);
node.AddChild(parameter);
return(true);
}
return(false);
}
public void Process(BuildMessageEventArgs args)
{
// Task Input / Outputs
if (args.Message.StartsWith(TaskParameterMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("Parameters");
var parameter = ItemGroupParser.ParsePropertyOrItemList(args.Message, TaskParameterMessagePrefix, stringTable);
folder.AddChild(parameter);
}
else if (args.Message.StartsWith(OutputItemsMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputItems");
var parameter = ItemGroupParser.ParsePropertyOrItemList(args.Message, OutputItemsMessagePrefix, stringTable);
folder.AddChild(parameter);
}
else if (args.Message.StartsWith(OutputPropertyMessagePrefix))
{
var task = GetTask(args);
var folder = task.GetOrCreateNodeWithName <Folder>("OutputProperties");
var parameter = ItemGroupParser.ParsePropertyOrItemList(args.Message, OutputPropertyMessagePrefix, stringTable);
folder.AddChild(parameter);
}
// Item / Property groups
else if (args.Message.StartsWith(PropertyGroupMessagePrefix))
{
AddPropertyGroup(args, PropertyGroupMessagePrefix);
}
else if (args.Message.StartsWith(ItemGroupIncludeMessagePrefix))
{
AddItemGroup(args, ItemGroupIncludeMessagePrefix, new AddItem());
}
else if (args.Message.StartsWith(ItemGroupRemoveMessagePrefix))
{
AddItemGroup(args, ItemGroupRemoveMessagePrefix, new RemoveItem());
}
else
{
// This was command line arguments for task
var taskArgs = args as TaskCommandLineEventArgs;
if (taskArgs != null)
{
AddCommandLine(taskArgs);
return;
}
// A task from assembly message (parses out the task name and assembly path).
const string taskAssemblyPattern = "Using \"(?<task>.+)\" task from (assembly|the task factory) \"(?<assembly>.+)\"\\.";
var match = Regex.Match(args.Message, taskAssemblyPattern);
if (match.Success)
{
construction.SetTaskAssembly(
stringTable.Intern(match.Groups["task"].Value),
stringTable.Intern(match.Groups["assembly"].Value));
}
else
{
// Just the generic log message or something we currently don't handle in the object model.
AddMessage(args, args.Message);
}
}
}
