/// <summary>
/// Constructor with location information
/// </summary>
public XmlAttributeWithLocation(string prefix, string localName, string namespaceURI, XmlDocument document, int lineNumber, int columnNumber)
: base(prefix, localName, namespaceURI, document)
{
XmlDocumentWithLocation documentWithLocation = (XmlDocumentWithLocation)document;
_elementLocation = ElementLocation.Create(documentWithLocation.FullPath, lineNumber, columnNumber);
}
internal InvalidProjectFileException (ElementLocation start, ElementLocation end, string message,
string errorSubcategory = null, string errorCode = null, string helpKeyword = null)
: this (start != null ? start.File : null, start != null ? start.Line : 0, start != null ? start.Column : 0,
end != null ? end.Line : 0, end != null ? end.Column : 0,
message, errorSubcategory, errorCode, helpKeyword)
{
}
public void SetUp()
{
LoggingServiceFactory loggingFactory = new LoggingServiceFactory(LoggerMode.Synchronous, 1);
_loggingService = loggingFactory.CreateInstance(BuildComponentType.LoggingService) as LoggingService;
_customLogger = new MyCustomLogger();
_mockHost = new MockHost();
_mockHost.LoggingService = _loggingService;
_loggingService.RegisterLogger(_customLogger);
_elementLocation = ElementLocation.Create("MockFile", 5, 5);
BuildRequest buildRequest = new BuildRequest(1 /* submissionId */, 1, 1, new List<string>(), null, BuildEventContext.Invalid, null);
BuildRequestConfiguration configuration = new BuildRequestConfiguration(1, new BuildRequestData("Nothing", new Dictionary<string, string>(), "4.0", new string[0], null), "2.0");
configuration.Project = new ProjectInstance(ProjectRootElement.Create());
BuildRequestEntry entry = new BuildRequestEntry(buildRequest, configuration);
BuildResult buildResult = new BuildResult(buildRequest, false);
buildResult.AddResultsForTarget("Build", new TargetResult(new TaskItem[] { new TaskItem("IamSuper", configuration.ProjectFullPath) }, TestUtilities.GetSkippedResult()));
_mockRequestCallback = new MockIRequestBuilderCallback(new BuildResult[] { buildResult });
entry.Builder = (IRequestBuilder)_mockRequestCallback;
_taskHost = new TaskHost(_mockHost, entry, _elementLocation, null /*Dont care about the callback either unless doing a build*/);
_taskHost.LoggingContext = new TaskLoggingContext(_loggingService, BuildEventContext.Invalid);
}
/// <summary>
/// Cloning constructor
/// </summary>
private ProjectPropertyGroupTaskPropertyInstance(ProjectPropertyGroupTaskPropertyInstance that)
{
// All fields are immutable
_name = that._name;
_value = that._value;
_condition = that._condition;
_location = that._location;
_conditionLocation = that._conditionLocation;
}
/// <summary>
/// Constructor with location information
/// </summary>
public XmlElementWithLocation(string prefix, string localName, string namespaceURI, XmlDocumentWithLocation document, int lineNumber, int columnNumber)
: base(prefix, localName, namespaceURI, document)
{
// Subtract one, just to give the same value as the old code did.
// In the past we pointed to the column of the open angle bracket whereas the XmlTextReader points to the first character of the element name.
// In well formed XML these are always adjacent on the same line, so it's safe to subtract one.
// If we're loading from a stream it's zero, so don't subtract one.
XmlDocumentWithLocation documentWithLocation = (XmlDocumentWithLocation)document;
int adjustedColumn = (columnNumber == 0) ? columnNumber : columnNumber - 1;
_elementLocation = ElementLocation.Create(documentWithLocation.FullPath, lineNumber, adjustedColumn);
}
/// <summary>
/// Constructor called by the Evaluator.
/// </summary>
internal ProjectPropertyGroupTaskPropertyInstance(string name, string value, string condition, ElementLocation location, ElementLocation conditionLocation)
{
ErrorUtilities.VerifyThrowInternalNull(name, "name");
ErrorUtilities.VerifyThrowInternalNull(value, "value");
ErrorUtilities.VerifyThrowInternalNull(condition, "condition");
ErrorUtilities.VerifyThrowInternalNull(location, "location");
_name = name;
_value = value;
_condition = condition;
_location = location;
_conditionLocation = conditionLocation;
}
/// <summary>
/// Constructor called by Evaluator
/// </summary>
internal ProjectTaskOutputPropertyInstance(string propertyName, string taskParameter, string condition, ElementLocation location, ElementLocation propertyNameLocation, ElementLocation taskParameterLocation, ElementLocation conditionLocation)
{
ErrorUtilities.VerifyThrowInternalLength(propertyName, "propertyName");
ErrorUtilities.VerifyThrowInternalLength(taskParameter, "taskParameter");
ErrorUtilities.VerifyThrowInternalNull(location, "location");
ErrorUtilities.VerifyThrowInternalNull(propertyNameLocation, "propertyNameLocation");
ErrorUtilities.VerifyThrowInternalNull(taskParameterLocation, "taskParameterLocation");
_propertyName = propertyName;
_taskParameter = taskParameter;
_condition = condition;
_location = location;
_propertyNameLocation = propertyNameLocation;
_taskParameterLocation = taskParameterLocation;
_conditionLocation = conditionLocation;
}
/// <summary>
/// Constructor called by evaluator
/// </summary>
internal ProjectTaskOutputItemInstance(string itemType, string taskParameter, string condition, ElementLocation location, ElementLocation itemTypeLocation, ElementLocation taskParameterLocation, ElementLocation conditionLocation)
{
ErrorUtilities.VerifyThrowInternalLength(itemType, "itemType");
ErrorUtilities.VerifyThrowInternalLength(taskParameter, "taskParameter");
ErrorUtilities.VerifyThrowInternalNull(location, "location");
ErrorUtilities.VerifyThrowInternalNull(itemTypeLocation, "itemTypeLocation");
ErrorUtilities.VerifyThrowInternalNull(taskParameterLocation, "taskParameterLocation");
_itemType = itemType;
_taskParameter = taskParameter;
_condition = condition;
_location = location;
_itemTypeLocation = itemTypeLocation;
_taskParameterLocation = taskParameterLocation;
_conditionLocation = conditionLocation;
}
/// <summary>
/// Constructor called by Evaluator.
/// All parameters are in the unevaluated state.
/// </summary>
internal ProjectOnErrorInstance
(
string executeTargets,
string condition,
ElementLocation location,
ElementLocation executeTargetsLocation,
ElementLocation conditionLocation
)
{
ErrorUtilities.VerifyThrowInternalLength(executeTargets, "executeTargets");
ErrorUtilities.VerifyThrowInternalNull(condition, "condition");
ErrorUtilities.VerifyThrowInternalNull(location, "location");
_executeTargets = executeTargets;
_condition = condition;
_location = location;
_executeTargetsLocation = executeTargetsLocation;
_conditionLocation = conditionLocation;
}
/// <summary>
/// Constructor called by the Evaluator.
/// Assumes ProjectPropertyGroupTaskPropertyInstance is an immutable type.
/// </summary>
internal ProjectPropertyGroupTaskInstance
(
string condition,
ElementLocation location,
ElementLocation conditionLocation,
IEnumerable<ProjectPropertyGroupTaskPropertyInstance> properties
)
{
ErrorUtilities.VerifyThrowInternalNull(condition, "condition");
ErrorUtilities.VerifyThrowInternalNull(location, "location");
ErrorUtilities.VerifyThrowInternalNull(properties, "properties");
_condition = condition;
_location = location;
_conditionLocation = conditionLocation;
if (properties != null)
{
_properties = (properties is ICollection<ProjectPropertyGroupTaskPropertyInstance>) ?
((ICollection<ProjectPropertyGroupTaskPropertyInstance>)properties) :
new List<ProjectPropertyGroupTaskPropertyInstance>(properties);
}
}
/// <summary>
/// Constructor called by the Evaluator.
/// Assumes ProjectItemGroupTaskItemInstance is an immutable type.
/// </summary>
internal ProjectItemGroupTaskInstance
(
string condition,
ElementLocation location,
ElementLocation conditionLocation,
IEnumerable<ProjectItemGroupTaskItemInstance> items
)
{
ErrorUtilities.VerifyThrowInternalNull(condition, "condition");
ErrorUtilities.VerifyThrowInternalNull(location, "location");
ErrorUtilities.VerifyThrowInternalNull(items, "items");
_condition = condition;
_location = location;
_conditionLocation = conditionLocation;
if (items != null)
{
_items = (items is ICollection<ProjectItemGroupTaskItemInstance>) ?
((ICollection<ProjectItemGroupTaskItemInstance>)items) :
new List<ProjectItemGroupTaskItemInstance>(items);
}
}
/// <summary>
/// Pop the state most recently pushed by EnterState.
/// The identifier (location) of a Leave must match the Enter at the top of the stack,
/// to catch mismatched Leaves.
/// </summary>
internal static void LeaveState(ElementLocation location)
{
ErrorUtilities.VerifyThrow(s_initialized, "Not initialized");
ErrorUtilities.VerifyThrow(DebuggingEnabled, "Debugging not enabled");
ErrorUtilities.VerifyThrow(s_skippedEnters >= 0, "Left too many");
// Special case: elements added by editing, such as in a solution wrapper project,
// do not have line numbers. Such files cannot be debugged, so we special case
// such locations by doing nothing.
if (s_skippedEnters > 0)
{
s_skippedEnters--;
return;
}
s_islandThread.LeaveState(location);
}
/// <summary>
/// Constructor.
/// State is given arbitrary provided name, which will appear in the debugger callstack: "ASSEMBLYNAME!FILENAME.STATENAME(...LOCALS...)"
/// Early locals are any locals whose names and types available at the time the state was created. May be null.
/// "Calling Type.GetMethod() is slow (10,000 calls can take ~1 minute). So defer that to later."
/// CALLED ONLY FROM THE DEBUGGER MANAGER.
/// </summary>
internal DebuggerState(ElementLocation location, string name, ICollection<DebuggerLocalType> earlyLocalsTypes)
{
ErrorUtilities.VerifyThrowInternalNull(location, "location");
ErrorUtilities.VerifyThrowInternalLength(name, "name");
this.Location = location;
this.Name = name;
this.EarlyLocalsTypes = earlyLocalsTypes ?? ReadOnlyEmptyList<DebuggerLocalType>.Instance;
}
/// <summary>
/// Posts a Leave instruction to the island thread.
/// Called by debugger manager thread
/// If location is provided, verifies that the state being left is the state that was entered.
/// Stack may already be empty, in which case it is not modified.
/// </summary>
internal void LeaveState(ElementLocation location)
{
ErrorUtilities.VerifyThrow(location == null || location == _virtualStack.Peek().State.Location, "Mismatched leave was {0} expected {1}", location.LocationString, _virtualStack.Peek().State.Location.LocationString);
_debugAction = DebugAction.Leave;
if (_virtualStack.Count > 0) // May be falling out of the first enter
{
_virtualStack.Pop();
}
_workToDoEvent.Set();
_workDoneEvent.WaitOne();
}
/// <summary>
/// Gets the outputs (as an array of ITaskItem) from the specified output parameter.
/// </summary>
private ITaskItem[] GetItemOutputs(TaskPropertyInfo parameter, ElementLocation parameterLocation)
{
object outputs = _taskFactoryWrapper.GetPropertyValue(_taskInstance, parameter);
ITaskItem[] taskItemOutputs = outputs as ITaskItem[];
if (null == taskItemOutputs)
{
taskItemOutputs = new ITaskItem[] { (ITaskItem)outputs };
}
return taskItemOutputs;
}
/// <summary>
/// Gets the outputs (as an array of string values) from the specified output parameter.
/// </summary>
private string[] GetValueOutputs(TaskPropertyInfo parameter, ElementLocation parameterLocation)
{
object outputs = _taskFactoryWrapper.GetPropertyValue(_taskInstance, parameter);
Array convertibleOutputs = parameter.PropertyType.IsArray ? (Array)outputs : new object[] { outputs };
if (convertibleOutputs == null)
{
return null;
}
string[] stringOutputs = new string[convertibleOutputs.Length];
for (int i = 0; i < convertibleOutputs.Length; i++)
{
object output = convertibleOutputs.GetValue(i);
if (output != null)
{
stringOutputs[i] = (string)Convert.ChangeType(output, typeof(string), CultureInfo.InvariantCulture);
}
}
return stringOutputs;
}
/// <summary>
/// Called on the local side.
/// </summary>
private bool SetValueParameter(TaskPropertyInfo parameter, Type parameterType, string expandedParameterValue, ElementLocation parameterLocation)
{
if (parameterType == typeof(bool))
{
// Convert the string to the appropriate datatype, and set the task's parameter.
return InternalSetTaskParameter(parameter, ConversionUtilities.ConvertStringToBool(expandedParameterValue));
}
else if (parameterType == typeof(string))
{
return InternalSetTaskParameter(parameter, expandedParameterValue);
}
else
{
return InternalSetTaskParameter(parameter, Convert.ChangeType(expandedParameterValue, parameterType, CultureInfo.InvariantCulture));
}
}
/// <summary>
/// Given an instantiated task, this helper method sets the specified vector parameter. Vector parameters can be composed
/// of multiple item vectors. The semicolon is the only separator allowed, and white space around the semicolon is
/// ignored. Any item separator strings are not allowed, and embedded item vectors are not allowed.
/// </summary>
/// <remarks>This method is marked "internal" for unit-testing purposes only -- it should be "private" ideally.</remarks>
/// <example>
/// If @(CPPFiles) is a vector for the files a.cpp and b.cpp, and @(IDLFiles) is a vector for the files a.idl and b.idl:
///
/// "@(CPPFiles)" converts to { a.cpp, b.cpp }
///
/// "@(CPPFiles); c.cpp; @(IDLFiles); c.idl" converts to { a.cpp, b.cpp, c.cpp, a.idl, b.idl, c.idl }
///
/// "@(CPPFiles,';')" converts to <error>
///
/// "xxx@(CPPFiles)xxx" converts to <error>
/// </example>
private bool InitializeTaskVectorParameter
(
TaskPropertyInfo parameter,
Type parameterType,
string parameterValue,
ElementLocation parameterLocation,
bool isRequired,
out bool taskParameterSet
)
{
ErrorUtilities.VerifyThrow(parameterValue != null, "Didn't expect null parameterValue in InitializeTaskVectorParameter");
taskParameterSet = false;
bool success = false;
IList<TaskItem> finalTaskItems = _batchBucket.Expander.ExpandIntoTaskItemsLeaveEscaped(parameterValue, ExpanderOptions.ExpandAll, parameterLocation);
// If there were no items, don't change the parameter's value. EXCEPT if it's marked as a required
// parameter, in which case we made an explicit decision to pass in an empty array. This is
// to avoid project authors having to add Conditions on all their tasks to avoid calling them
// when a particular item list is empty. This way, we just call the task with an empty list,
// the task will loop over an empty list, and return quickly.
if ((finalTaskItems.Count > 0) || isRequired)
{
// If the task parameter is not a ITaskItem[], then we need to convert
// all the TaskItem's in our arraylist to the appropriate datatype.
success = SetParameterArray(parameter, parameterType, finalTaskItems, parameterLocation);
taskParameterSet = true;
}
else
{
success = true;
}
return success;
}
/// <summary>
/// Throw an invalid project exception indicating that the child is not valid beneath the element
/// </summary>
internal static void ThrowProjectInvalidChildElement(string name, string parentName, ElementLocation location)
{
ProjectErrorUtilities.ThrowInvalidProject(location, "UnrecognizedChildElement", name, parentName);
}
/// <summary>
/// Called on the local side.
/// </summary>
private bool SetTaskItemParameter(TaskPropertyInfo parameter, ITaskItem item, ElementLocation parameterLocation)
{
return InternalSetTaskParameter(parameter, item);
}
internal void FillLocation (XmlReader reader)
{
var l = reader as IXmlLineInfo;
if (l != null && l.HasLineInfo ())
Location = new ProjectElementLocation (reader.BaseURI, l);
if (reader.MoveToAttribute ("Condition") && l.HasLineInfo ())
ConditionLocation = new ProjectElementLocation (reader.BaseURI, l);
if (reader.MoveToAttribute ("Label") && l.HasLineInfo ())
LabelLocation = new ProjectElementLocation (reader.BaseURI, l);
reader.MoveToElement ();
}
/// <summary>
/// Set the specified parameter based on its type.
/// </summary>
private bool SetTaskParameter
(
string parameterName,
string parameterValue,
ElementLocation parameterLocation,
bool isRequired,
out bool parameterSet
)
{
bool success = false;
parameterSet = false;
try
{
// check if the task has a .NET property corresponding to the parameter
TaskPropertyInfo parameter = _taskFactoryWrapper.GetProperty(parameterName);
if (parameter != null)
{
Type parameterType = parameter.PropertyType;
// try to set the parameter
if (TaskParameterTypeVerifier.IsValidScalarInputParameter(parameterType))
{
success = InitializeTaskScalarParameter
(
parameter,
parameterType,
parameterValue,
parameterLocation,
out parameterSet
);
}
else if (TaskParameterTypeVerifier.IsValidVectorInputParameter(parameterType))
{
success = InitializeTaskVectorParameter
(
parameter,
parameterType,
parameterValue,
parameterLocation,
isRequired,
out parameterSet
);
}
else
{
_taskLoggingContext.LogError
(
new BuildEventFileInfo(parameterLocation),
"UnsupportedTaskParameterTypeError",
parameterType.FullName,
parameter.Name,
_taskName
);
}
if (!success)
{
// flag an error if the parameter could not be set
_taskLoggingContext.LogError
(
new BuildEventFileInfo(parameterLocation),
"InvalidTaskAttributeError",
parameterName,
parameterValue,
_taskName
);
}
}
else
{
// flag an error if we find a parameter that has no .NET property equivalent
_taskLoggingContext.LogError
(
new BuildEventFileInfo(parameterLocation),
"UnexpectedTaskAttribute",
parameterName,
_taskName
);
}
}
catch (AmbiguousMatchException)
{
_taskLoggingContext.LogError
(
new BuildEventFileInfo(parameterLocation),
"AmbiguousTaskParameterError",
_taskName,
parameterName
);
}
catch (ArgumentException)
{
ProjectErrorUtilities.ThrowInvalidProject
(
parameterLocation,
"SetAccessorNotAvailableOnTaskParameter",
parameterName,
_taskName
);
}
return success;
}
/// <summary>
/// Gets task item outputs
/// </summary>
private void GatherTaskItemOutputs(bool outputTargetIsItem, string outputTargetName, ITaskItem[] outputs, ElementLocation parameterLocation)
{
// if the task has generated outputs (if it didn't, don't do anything)
if (outputs != null)
{
if (outputTargetIsItem)
{
foreach (ITaskItem output in outputs)
{
// if individual items in the array are null, ignore them
if (output != null)
{
ProjectItemInstance newItem;
ProjectItemInstance.TaskItem outputAsProjectItem = output as ProjectItemInstance.TaskItem;
string parameterLocationEscaped = EscapingUtilities.EscapeWithCaching(parameterLocation.File);
if (outputAsProjectItem != null)
{
// The common case -- all items involved are Microsoft.Build.Execution.ProjectItemInstance.TaskItems.
// Furthermore, because that is true, we know by definition that they also implement ITaskItem2.
newItem = new ProjectItemInstance(_projectInstance, outputTargetName, outputAsProjectItem.IncludeEscaped, parameterLocationEscaped);
newItem.SetMetadata(outputAsProjectItem.MetadataCollection); // copy-on-write!
}
else
{
ITaskItem2 outputAsITaskItem2 = output as ITaskItem2;
if (outputAsITaskItem2 != null)
{
// Probably a Microsoft.Build.Utilities.TaskItem. Not quite as good, but we can still preserve escaping.
newItem = new ProjectItemInstance(_projectInstance, outputTargetName, outputAsITaskItem2.EvaluatedIncludeEscaped, parameterLocationEscaped);
// It would be nice to be copy-on-write here, but Utilities.TaskItem doesn't know about CopyOnWritePropertyDictionary.
foreach (DictionaryEntry entry in outputAsITaskItem2.CloneCustomMetadataEscaped())
{
newItem.SetMetadataOnTaskOutput((string)entry.Key, (string)entry.Value);
}
}
else
{
// Not a ProjectItemInstance.TaskItem or even a ITaskItem2, so we have to fake it.
// Setting an item spec expects the escaped value, as does setting metadata.
newItem = new ProjectItemInstance(_projectInstance, outputTargetName, EscapingUtilities.Escape(output.ItemSpec), parameterLocationEscaped);
foreach (DictionaryEntry entry in output.CloneCustomMetadata())
{
newItem.SetMetadataOnTaskOutput((string)entry.Key, EscapingUtilities.Escape((string)entry.Value));
}
}
}
_batchBucket.Lookup.AddNewItem(newItem);
}
}
if (_logTaskInputs && !_taskLoggingContext.LoggingService.OnlyLogCriticalEvents && outputs.Length > 0)
{
string parameterText = ItemGroupLoggingHelper.GetParameterText(
ResourceUtilities.FormatResourceString("OutputItemParameterMessagePrefix"),
outputTargetName,
outputs);
_taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
}
}
else
{
// to store an ITaskItem array in a property, join all the item-specs with semi-colons to make the
// property value, and ignore/discard the attributes on the ITaskItems.
//
// An empty ITaskItem[] should create a blank value property, for compatibility.
StringBuilder joinedOutputs = (outputs.Length == 0) ? new StringBuilder() : null;
foreach (ITaskItem output in outputs)
{
// if individual items in the array are null, ignore them
if (output != null)
{
joinedOutputs = joinedOutputs ?? new StringBuilder();
if (joinedOutputs.Length > 0)
{
joinedOutputs.Append(';');
}
ITaskItem2 outputAsITaskItem2 = output as ITaskItem2;
if (outputAsITaskItem2 != null)
{
joinedOutputs.Append(outputAsITaskItem2.EvaluatedIncludeEscaped);
}
else
{
joinedOutputs.Append(EscapingUtilities.Escape(output.ItemSpec));
}
}
}
if (joinedOutputs != null)
{
var outputString = joinedOutputs.ToString();
if (_logTaskInputs && !_taskLoggingContext.LoggingService.OnlyLogCriticalEvents)
{
_taskLoggingContext.LogComment(MessageImportance.Low, "OutputPropertyLogMessage", outputTargetName, outputString);
}
_batchBucket.Lookup.SetProperty(ProjectPropertyInstance.Create(outputTargetName, outputString, parameterLocation, _projectInstance.IsImmutable));
}
}
}
}
/// <summary>
/// Enter and immediately leave a state, so that any breakpoint can be hit.
/// </summary>
internal static void PulseState(ElementLocation location, IDictionary<string, object> locals)
{
ErrorUtilities.VerifyThrow(s_initialized, "Not initialized");
ErrorUtilities.VerifyThrow(DebuggingEnabled, "Debugging not enabled");
EnterState(location, locals);
LeaveState(location);
}
/// <summary>
/// Called on the local side.
/// </summary>
private bool SetParameterArray(TaskPropertyInfo parameter, Type parameterType, IList<TaskItem> taskItems, ElementLocation parameterLocation)
{
TaskItem currentItem = null;
try
{
// Loop through all the TaskItems in our arraylist, and convert them.
ArrayList finalTaskInputs = new ArrayList();
if (parameterType != typeof(ITaskItem[]))
{
foreach (TaskItem item in taskItems)
{
currentItem = item;
if (parameterType == typeof(string[]))
{
finalTaskInputs.Add(item.ItemSpec);
}
else if (parameterType == typeof(bool[]))
{
finalTaskInputs.Add(ConversionUtilities.ConvertStringToBool(item.ItemSpec));
}
else
{
finalTaskInputs.Add(Convert.ChangeType(item.ItemSpec, parameterType.GetElementType(), CultureInfo.InvariantCulture));
}
}
}
else
{
foreach (TaskItem item in taskItems)
{
// if we've been asked to remote these items then
// remember them so we can disconnect them from remoting later
RecordItemForDisconnectIfNecessary(item);
finalTaskInputs.Add(item);
}
}
return InternalSetTaskParameter(parameter, finalTaskInputs.ToArray(parameterType.GetElementType()));
}
catch (Exception ex)
{
if (ex is InvalidCastException || // invalid type
ex is ArgumentException || // can't convert to bool
ex is FormatException || // bad string representation of a type
ex is OverflowException) // overflow when converting string representation of a numerical type
{
ProjectErrorUtilities.ThrowInvalidProject
(
parameterLocation,
"InvalidTaskParameterValueError",
currentItem.ItemSpec,
parameter.Name,
parameterType.FullName,
_taskName
);
}
throw;
}
}
/// <summary>
/// Gather task outputs in array form
/// </summary>
private void GatherArrayStringAndValueOutputs(bool outputTargetIsItem, string outputTargetName, TaskPropertyInfo parameter, string[] outputs, ElementLocation parameterLocation)
{
// if the task has generated outputs (if it didn't, don't do anything)
if (outputs != null)
{
if (outputTargetIsItem)
{
// to store the outputs as items, use the string representations of the outputs as item-specs
foreach (string output in outputs)
{
// if individual outputs in the array are null, ignore them
if (output != null)
{
// attempting to put an empty string into an item is a no-op.
if (output.Length > 0)
{
_batchBucket.Lookup.AddNewItem(new ProjectItemInstance(_projectInstance, outputTargetName, EscapingUtilities.Escape(output), EscapingUtilities.Escape(parameterLocation.File)));
}
}
}
if (_logTaskInputs && !_taskLoggingContext.LoggingService.OnlyLogCriticalEvents && outputs.Length > 0)
{
string parameterText = ItemGroupLoggingHelper.GetParameterText(ResourceUtilities.FormatResourceString("OutputItemParameterMessagePrefix"), outputTargetName, outputs);
_taskLoggingContext.LogCommentFromText(MessageImportance.Low, parameterText);
}
}
else
{
// to store an object array in a property, join all the string representations of the objects with
// semi-colons to make the property value
//
// An empty ITaskItem[] should create a blank value property, for compatibility.
StringBuilder joinedOutputs = (outputs.Length == 0) ? new StringBuilder() : null;
foreach (string output in outputs)
{
// if individual outputs in the array are null, ignore them
if (output != null)
{
joinedOutputs = joinedOutputs ?? new StringBuilder();
if (joinedOutputs.Length > 0)
{
joinedOutputs.Append(';');
}
joinedOutputs.Append(EscapingUtilities.Escape(output));
}
}
if (joinedOutputs != null)
{
var outputString = joinedOutputs.ToString();
if (_logTaskInputs && !_taskLoggingContext.LoggingService.OnlyLogCriticalEvents)
{
_taskLoggingContext.LogComment(MessageImportance.Low, "OutputPropertyLogMessage", outputTargetName, outputString);
}
_batchBucket.Lookup.SetProperty(ProjectPropertyInstance.Create(outputTargetName, outputString, parameterLocation, _projectInstance.IsImmutable));
}
}
}
}
/// <summary>
/// Given an instantiated task, this helper method sets the specified scalar parameter based on its type.
/// </summary>
private bool InitializeTaskScalarParameter
(
TaskPropertyInfo parameter,
Type parameterType,
string parameterValue,
ElementLocation parameterLocation,
out bool taskParameterSet
)
{
taskParameterSet = false;
bool success = false;
try
{
if (parameterType == typeof(ITaskItem))
{
// We don't know how many items we're going to end up with, but we'll
// keep adding them to this arraylist as we find them.
IList<TaskItem> finalTaskItems = _batchBucket.Expander.ExpandIntoTaskItemsLeaveEscaped(parameterValue, ExpanderOptions.ExpandAll, parameterLocation);
if (finalTaskItems.Count == 0)
{
success = true;
}
else
{
if (finalTaskItems.Count != 1)
{
// We only allow a single item to be passed into a parameter of ITaskItem.
// Some of the computation (expansion) here is expensive, so don't make the above
// "if" statement directly part of the first param to VerifyThrowInvalidProject.
ProjectErrorUtilities.VerifyThrowInvalidProject
(
false,
parameterLocation,
"CannotPassMultipleItemsIntoScalarParameter",
_batchBucket.Expander.ExpandIntoStringAndUnescape(parameterValue, ExpanderOptions.ExpandAll, parameterLocation),
parameter.Name,
parameterType.FullName,
_taskName
);
}
RecordItemForDisconnectIfNecessary(finalTaskItems[0]);
success = SetTaskItemParameter(parameter, finalTaskItems[0], parameterLocation);
taskParameterSet = true;
}
}
else
{
// Expand out all the metadata, properties, and item vectors in the string.
string expandedParameterValue = _batchBucket.Expander.ExpandIntoStringAndUnescape(parameterValue, ExpanderOptions.ExpandAll, parameterLocation);
if (expandedParameterValue.Length == 0)
{
success = true;
}
else
{
success = SetValueParameter(parameter, parameterType, expandedParameterValue, parameterLocation);
taskParameterSet = true;
}
}
}
catch (Exception ex)
{
if (ex is InvalidCastException || // invalid type
ex is ArgumentException || // can't convert to bool
ex is FormatException || // bad string representation of a type
ex is OverflowException) // overflow when converting string representation of a numerical type
{
ProjectErrorUtilities.ThrowInvalidProject
(
parameterLocation,
"InvalidTaskParameterValueError",
_batchBucket.Expander.ExpandIntoStringAndUnescape(parameterValue, ExpanderOptions.ExpandAll, parameterLocation),
parameter.Name,
parameterType.FullName,
_taskName
);
}
throw;
}
return success;
}
public void TearDown()
{
_customLogger = null;
_mockHost = null;
_elementLocation = null;
_taskHost = null;
}
/// <summary>
/// Initialize to run a specific task.
/// </summary>
void ITaskExecutionHost.InitializeForTask(IBuildEngine2 buildEngine, TargetLoggingContext loggingContext, ProjectInstance projectInstance, string taskName, ElementLocation taskLocation, ITaskHost taskHost, bool continueOnError, AppDomainSetup appDomainSetup, bool isOutOfProc, CancellationToken cancellationToken)
{
_buildEngine = buildEngine;
_projectInstance = projectInstance;
_targetLoggingContext = loggingContext;
_taskName = taskName;
_taskLocation = taskLocation;
_cancellationTokenRegistration = cancellationToken.Register(this.Cancel);
_taskHost = taskHost;
_continueOnError = continueOnError;
_taskExecutionIdle.Set();
this.AppDomainSetup = appDomainSetup;
this.IsOutOfProc = isOutOfProc;
}
/// <summary>
/// Retrieve the outputs from the task.
/// </summary>
/// <returns>True of the outputs were gathered successfully, false otherwise.</returns>
bool ITaskExecutionHost.GatherTaskOutputs(string parameterName, ElementLocation parameterLocation, bool outputTargetIsItem, string outputTargetName)
{
ErrorUtilities.VerifyThrow(_taskFactoryWrapper != null, "Need a taskFactoryWrapper to retrieve outputs from.");
bool gatheredGeneratedOutputsSuccessfully = true;
try
{
TaskPropertyInfo parameter = _taskFactoryWrapper.GetProperty(parameterName);
// flag an error if we find a parameter that has no .NET property equivalent
ProjectErrorUtilities.VerifyThrowInvalidProject
(
parameter != null,
parameterLocation,
"UnexpectedTaskOutputAttribute",
parameterName,
_taskName
);
// output parameters must have their corresponding .NET properties marked with the Output attribute
ProjectErrorUtilities.VerifyThrowInvalidProject
(
_taskFactoryWrapper.GetNamesOfPropertiesWithOutputAttribute.ContainsKey(parameterName),
parameterLocation,
"UnmarkedOutputTaskParameter",
parameter.Name,
_taskName
);
// grab the outputs from the task's designated output parameter (which is a .NET property)
Type type = parameter.PropertyType;
if (TaskParameterTypeVerifier.IsAssignableToITask(type))
{
ITaskItem[] outputs = GetItemOutputs(parameter, parameterLocation);
GatherTaskItemOutputs(outputTargetIsItem, outputTargetName, outputs, parameterLocation);
}
else if (TaskParameterTypeVerifier.IsValueTypeOutputParameter(type))
{
string[] outputs = GetValueOutputs(parameter, parameterLocation);
GatherArrayStringAndValueOutputs(outputTargetIsItem, outputTargetName, parameter, outputs, parameterLocation);
}
else
{
ProjectErrorUtilities.VerifyThrowInvalidProject
(
false,
parameterLocation,
"UnsupportedTaskParameterTypeError",
parameter.PropertyType.FullName,
parameter.Name,
_taskName
);
}
}
catch (InvalidOperationException e)
{
// handle invalid TaskItems in task outputs
_targetLoggingContext.LogError
(
new BuildEventFileInfo(parameterLocation),
"InvalidTaskItemsInTaskOutputs",
_taskName,
parameterName,
e.Message
);
gatheredGeneratedOutputsSuccessfully = false;
}
catch (TargetInvocationException e)
{
// handle any exception thrown by the task's getter
// Exception thrown by the called code itself
// Log the stack, so the task vendor can fix their code
// Log the task line number, whatever the value of ContinueOnError;
// because this will be a hard error anyway.
_targetLoggingContext.LogFatalTaskError
(
new BuildEventFileInfo(parameterLocation),
e.InnerException,
_taskName
);
// We do not recover from a task exception while getting outputs,
// so do not merely set gatheredGeneratedOutputsSuccessfully = false; here
ProjectErrorUtilities.VerifyThrowInvalidProject
(
false,
parameterLocation,
"FailedToRetrieveTaskOutputs",
_taskName,
parameterName,
e.InnerException.Message
);
}
catch (Exception e)
{
// Catching Exception, but rethrowing unless it's a well-known exception.
if (ExceptionHandling.NotExpectedReflectionException(e))
{
throw;
}
ProjectErrorUtilities.VerifyThrowInvalidProject
(
false,
parameterLocation,
"FailedToRetrieveTaskOutputs",
_taskName,
parameterName,
e.Message
);
}
return gatheredGeneratedOutputsSuccessfully;
}
private void Parse()
{
// XML guarantees exactly one root element
XmlElementWithLocation element = _document.DocumentElement as XmlElementWithLocation;
if (element is null)
{
ProjectErrorUtilities.ThrowInvalidProject(ElementLocation.Create(_document.FullPath), "NoRootProjectElement", XMakeElements.project);
}
ProjectErrorUtilities.VerifyThrowInvalidProject(element.Name != XMakeElements.visualStudioProject, element.Location, "ProjectUpgradeNeeded", _project.FullPath);
ProjectErrorUtilities.VerifyThrowInvalidProject(element.LocalName == XMakeElements.project, element.Location, "UnrecognizedElement", element.Name);
// If a namespace was specified it must be the default MSBuild namespace.
if (!ProjectXmlUtilities.VerifyValidProjectNamespace(element))
{
ProjectErrorUtilities.ThrowInvalidProject(element.Location, "ProjectMustBeInMSBuildXmlNamespace",
XMakeAttributes.defaultXmlNamespace);
}
else
{
_project.XmlNamespace = element.NamespaceURI;
}
// Historically, we allow any attribute on the Project element
// The element wasn't available to the ProjectRootElement constructor so we have to set it now
_project.SetProjectRootElementFromParser(element, _project);
foreach (XmlElementWithLocation childElement in ProjectXmlUtilities.GetVerifyThrowProjectChildElements(element))
{
switch (childElement.Name)
{
case XMakeElements.propertyGroup:
_project.AppendParentedChildNoChecks(ParseProjectPropertyGroupElement(childElement, _project));
break;
case XMakeElements.itemGroup:
_project.AppendParentedChildNoChecks(ParseProjectItemGroupElement(childElement, _project));
break;
case XMakeElements.importGroup:
_project.AppendParentedChildNoChecks(ParseProjectImportGroupElement(childElement, _project));
break;
case XMakeElements.import:
_project.AppendParentedChildNoChecks(ParseProjectImportElement(childElement, _project));
break;
case XMakeElements.usingTask:
_project.AppendParentedChildNoChecks(ParseProjectUsingTaskElement(childElement));
break;
case XMakeElements.target:
_project.AppendParentedChildNoChecks(ParseProjectTargetElement(childElement));
break;
case XMakeElements.itemDefinitionGroup:
_project.AppendParentedChildNoChecks(ParseProjectItemDefinitionGroupElement(childElement));
break;
case XMakeElements.choose:
_project.AppendParentedChildNoChecks(ParseProjectChooseElement(childElement, _project, 0 /* nesting depth */));
break;
case XMakeElements.projectExtensions:
_project.AppendParentedChildNoChecks(ParseProjectExtensionsElement(childElement));
break;
case XMakeElements.sdk:
_project.AppendParentedChildNoChecks(ParseProjectSdkElement(childElement));
break;
// Obsolete
case XMakeElements.error:
case XMakeElements.warning:
case XMakeElements.message:
ProjectErrorUtilities.ThrowInvalidProject(childElement.Location, "ErrorWarningMessageNotSupported", childElement.Name);
break;
default:
ProjectXmlUtilities.ThrowProjectInvalidChildElement(childElement.Name, childElement.ParentNode.Name, childElement.Location);
break;
}
}
}