public void TestTaskResolutionFailureWithUsingTask()
{
Assert.Throws<InvalidProjectFileException>(() =>
{
_loggingService = new MockLoggingService();
Dispose();
_host = new TaskExecutionHost();
TargetLoggingContext tlc = new TargetLoggingContext(_loggingService, new BuildEventContext(1, 1, BuildEventContext.InvalidProjectContextId, 1));
ProjectInstance project = CreateTestProject();
_host.InitializeForTask
(
this,
tlc,
project,
"TaskWithMissingAssembly",
ElementLocation.Create("none", 1, 1),
this,
false,
null,
false,
CancellationToken.None
);
_host.FindTask(null);
_host.InitializeForBatch(new TaskLoggingContext(_loggingService, tlc.BuildEventContext), _bucket, null);
}
);
}
/// <summary>
/// Initialize the host object
/// </summary>
/// <param name="throwOnExecute">Should the task throw when executed</param>
private void InitializeHost(bool throwOnExecute)
{
_loggingService = LoggingService.CreateLoggingService(LoggerMode.Synchronous, 1) as ILoggingService;
_logger = new MockLogger();
_loggingService.RegisterLogger(_logger);
_host = new TaskExecutionHost();
TargetLoggingContext tlc = new TargetLoggingContext(_loggingService, new BuildEventContext(1, 1, BuildEventContext.InvalidProjectContextId, 1));
// Set up a temporary project and add some items to it.
ProjectInstance project = CreateTestProject();
TypeLoader typeLoader = new TypeLoader(new TypeFilter(IsTaskFactoryClass));
AssemblyLoadInfo loadInfo = AssemblyLoadInfo.Create(Assembly.GetAssembly(typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory)).FullName, null);
LoadedType loadedType = new LoadedType(typeof(TaskBuilderTestTask.TaskBuilderTestTaskFactory), loadInfo);
TaskBuilderTestTask.TaskBuilderTestTaskFactory taskFactory = new TaskBuilderTestTask.TaskBuilderTestTaskFactory();
taskFactory.ThrowOnExecute = throwOnExecute;
string taskName = "TaskBuilderTestTask";
(_host as TaskExecutionHost)._UNITTESTONLY_TaskFactoryWrapper = new TaskFactoryWrapper(taskFactory, loadedType, taskName, null);
_host.InitializeForTask
(
this,
tlc,
project,
taskName,
ElementLocation.Create("none", 1, 1),
this,
false,
null,
false,
CancellationToken.None
);
ProjectTaskInstance taskInstance = project.Targets["foo"].Tasks.First();
TaskLoggingContext talc = tlc.LogTaskBatchStarted(".", taskInstance);
ItemDictionary<ProjectItemInstance> itemsByName = new ItemDictionary<ProjectItemInstance>();
ProjectItemInstance item = new ProjectItemInstance(project, "ItemListContainingOneItem", "a.cs", ".");
item.SetMetadata("Culture", "fr-fr");
itemsByName.Add(item);
_oneItem = new ITaskItem[] { new TaskItem(item) };
item = new ProjectItemInstance(project, "ItemListContainingTwoItems", "b.cs", ".");
ProjectItemInstance item2 = new ProjectItemInstance(project, "ItemListContainingTwoItems", "c.cs", ".");
item.SetMetadata("HintPath", "c:\\foo");
item2.SetMetadata("HintPath", "c:\\bar");
itemsByName.Add(item);
itemsByName.Add(item2);
_twoItems = new ITaskItem[] { new TaskItem(item), new TaskItem(item2) };
_bucket = new ItemBucket(new string[0], new Dictionary<string, string>(), new Lookup(itemsByName, new PropertyDictionary<ProjectPropertyInstance>(), null), 0);
_host.FindTask(null);
_host.InitializeForBatch(talc, _bucket, null);
_parametersSetOnTask = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
_outputsReadFromTask = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
}
/// <summary>
/// Cleans up after the test
/// </summary>
public void Dispose()
{
if (_host != null)
{
((IDisposable)_host).Dispose();
}
_host = null;
}
public void TestTaskResolutionFailureWithNoUsingTask()
{
Dispose();
_host = new TaskExecutionHost();
TargetLoggingContext tlc = new TargetLoggingContext(_loggingService, new BuildEventContext(1, 1, BuildEventContext.InvalidProjectContextId, 1));
ProjectInstance project = CreateTestProject();
_host.InitializeForTask
(
this,
tlc,
project,
"TaskWithNoUsingTask",
ElementLocation.Create("none", 1, 1),
this,
false,
null,
false,
CancellationToken.None
);
_host.FindTask(null);
_host.InitializeForBatch(new TaskLoggingContext(_loggingService, tlc.BuildEventContext), _bucket, null);
_logger.AssertLogContains("MSB4036");
}
/// <summary>
/// Gathers task outputs in two ways:
/// 1) Given an instantiated task that has finished executing, it extracts the outputs using .NET reflection.
/// 2) Otherwise, it parses the task's output specifications and (statically) infers the outputs.
/// </summary>
/// <param name="taskExecutionHost">The task execution host.</param>
/// <param name="howToExecuteTask">The task execution mode</param>
/// <param name="bucket">The bucket to which the task execution belongs.</param>
/// <returns>true, if successful</returns>
private bool GatherTaskOutputs(ITaskExecutionHost taskExecutionHost, TaskExecutionMode howToExecuteTask, ItemBucket bucket)
{
bool gatheredTaskOutputsSuccessfully = true;
foreach (ProjectTaskInstanceChild taskOutputSpecification in _taskNode.Outputs)
{
// if the task's outputs are supposed to be gathered
bool condition = ConditionEvaluator.EvaluateCondition
(
taskOutputSpecification.Condition,
ParserOptions.AllowAll,
bucket.Expander,
ExpanderOptions.ExpandAll,
_buildRequestEntry.ProjectRootDirectory,
taskOutputSpecification.ConditionLocation,
_targetLoggingContext.LoggingService,
_targetLoggingContext.BuildEventContext
);
if (condition)
{
string taskParameterName = null;
bool outputTargetIsItem = false;
string outputTargetName = null;
// check where the outputs are going -- into a vector, or a property?
ProjectTaskOutputItemInstance taskOutputItemInstance = taskOutputSpecification as ProjectTaskOutputItemInstance;
if (taskOutputItemInstance != null)
{
// expand all embedded properties, item metadata and item vectors in the item type name
outputTargetIsItem = true;
outputTargetName = bucket.Expander.ExpandIntoStringAndUnescape(taskOutputItemInstance.ItemType, ExpanderOptions.ExpandAll, taskOutputItemInstance.ItemTypeLocation);
taskParameterName = taskOutputItemInstance.TaskParameter;
ProjectErrorUtilities.VerifyThrowInvalidProject
(
outputTargetName.Length > 0,
taskOutputItemInstance.ItemTypeLocation,
"InvalidEvaluatedAttributeValue",
outputTargetName,
taskOutputItemInstance.ItemType,
XMakeAttributes.itemName,
XMakeElements.output
);
}
else
{
ProjectTaskOutputPropertyInstance taskOutputPropertyInstance = taskOutputSpecification as ProjectTaskOutputPropertyInstance;
outputTargetIsItem = false;
// expand all embedded properties, item metadata and item vectors in the property name
outputTargetName = bucket.Expander.ExpandIntoStringAndUnescape(taskOutputPropertyInstance.PropertyName, ExpanderOptions.ExpandAll, taskOutputPropertyInstance.PropertyNameLocation);
taskParameterName = taskOutputPropertyInstance.TaskParameter;
ProjectErrorUtilities.VerifyThrowInvalidProject
(
outputTargetName.Length > 0,
taskOutputPropertyInstance.PropertyNameLocation,
"InvalidEvaluatedAttributeValue",
outputTargetName,
taskOutputPropertyInstance.PropertyName,
XMakeAttributes.propertyName,
XMakeElements.output
);
}
string unexpandedTaskParameterName = taskParameterName;
taskParameterName = bucket.Expander.ExpandIntoStringAndUnescape(taskParameterName, ExpanderOptions.ExpandAll, taskOutputSpecification.TaskParameterLocation);
ProjectErrorUtilities.VerifyThrowInvalidProject
(
taskParameterName.Length > 0,
taskOutputSpecification.TaskParameterLocation,
"InvalidEvaluatedAttributeValue",
taskParameterName,
unexpandedTaskParameterName,
XMakeAttributes.taskParameter,
XMakeElements.output
);
// if we're gathering outputs by .NET reflection
if (howToExecuteTask == TaskExecutionMode.ExecuteTaskAndGatherOutputs)
{
gatheredTaskOutputsSuccessfully = taskExecutionHost.GatherTaskOutputs(taskParameterName, taskOutputSpecification.Location, outputTargetIsItem, outputTargetName);
}
else
{
// If we're inferring outputs based on information in the task and <Output> tags
ErrorUtilities.VerifyThrow(howToExecuteTask == TaskExecutionMode.InferOutputsOnly, "should be inferring");
// UNDONE: Refactor this method to use the same flag/string paradigm we use above, rather than two strings and the task output spec.
InferTaskOutputs(bucket.Lookup, taskOutputSpecification, taskParameterName, outputTargetName, outputTargetName, bucket);
}
}
if (!gatheredTaskOutputsSuccessfully)
{
break;
}
}
return gatheredTaskOutputsSuccessfully;
}
/// <summary>
/// Execute a task object for a given bucket.
/// </summary>
/// <param name="taskExecutionHost">The host used to execute the task.</param>
/// <param name="taskLoggingContext">The logging context.</param>
/// <param name="taskHost">The task host for the task.</param>
/// <param name="bucket">The batching bucket</param>
/// <param name="howToExecuteTask">The task execution mode</param>
/// <returns>The result of running the task.</returns>
private async Task<WorkUnitResult> ExecuteInstantiatedTask(ITaskExecutionHost taskExecutionHost, TaskLoggingContext taskLoggingContext, TaskHost taskHost, ItemBucket bucket, TaskExecutionMode howToExecuteTask)
{
UpdateContinueOnError(bucket, taskHost);
bool taskResult = false;
WorkUnitResultCode resultCode = WorkUnitResultCode.Success;
WorkUnitActionCode actionCode = WorkUnitActionCode.Continue;
if (!taskExecutionHost.SetTaskParameters(_taskNode.ParametersForBuild))
{
// The task cannot be initialized.
ProjectErrorUtilities.VerifyThrowInvalidProject(false, _targetChildInstance.Location, "TaskParametersError", _taskNode.Name, String.Empty);
}
else
{
bool taskReturned = false;
Exception taskException = null;
// If this is the MSBuild task, we need to execute it's special internal method.
TaskExecutionHost host = taskExecutionHost as TaskExecutionHost;
Type taskType = host.TaskInstance.GetType();
try
{
if (taskType == typeof(MSBuild))
{
MSBuild msbuildTask = host.TaskInstance as MSBuild;
ErrorUtilities.VerifyThrow(msbuildTask != null, "Unexpected MSBuild internal task.");
_targetBuilderCallback.EnterMSBuildCallbackState();
try
{
taskResult = await msbuildTask.ExecuteInternal();
}
finally
{
_targetBuilderCallback.ExitMSBuildCallbackState();
}
}
else if (taskType == typeof(CallTarget))
{
CallTarget callTargetTask = host.TaskInstance as CallTarget;
taskResult = await callTargetTask.ExecuteInternal();
}
else
{
using (FullTracking.Track(taskLoggingContext.TargetLoggingContext.Target.Name, _taskNode.Name, _buildRequestEntry.ProjectRootDirectory, _buildRequestEntry.RequestConfiguration.Project.PropertiesToBuildWith))
{
taskResult = taskExecutionHost.Execute();
}
}
}
catch (Exception ex)
{
if (ExceptionHandling.IsCriticalException(ex) || (Environment.GetEnvironmentVariable("MSBUILDDONOTCATCHTASKEXCEPTIONS") == "1"))
{
throw;
}
taskException = ex;
}
if (taskException == null)
{
taskReturned = true;
// Set the property "MSBuildLastTaskResult" to reflect whether the task succeeded or not.
// The main use of this is if ContinueOnError is true -- so that the next task can consult the result.
// So we want it to be "false" even if ContinueOnError is true.
// The constants "true" and "false" should NOT be localized. They become property values.
bucket.Lookup.SetProperty(ProjectPropertyInstance.Create(ReservedPropertyNames.lastTaskResult, taskResult ? "true" : "false", true/* may be reserved */, _buildRequestEntry.RequestConfiguration.Project.IsImmutable));
}
else
{
Type type = taskException.GetType();
if (type == typeof(LoggerException))
{
// if a logger has failed, abort immediately
// Polite logger failure
_continueOnError = ContinueOnError.ErrorAndStop;
// Rethrow wrapped in order to avoid losing the callstack
throw new LoggerException(taskException.Message, taskException);
}
else if (type == typeof(InternalLoggerException))
{
// Logger threw arbitrary exception
_continueOnError = ContinueOnError.ErrorAndStop;
InternalLoggerException ex = taskException as InternalLoggerException;
// Rethrow wrapped in order to avoid losing the callstack
throw new InternalLoggerException(taskException.Message, taskException, ex.BuildEventArgs, ex.ErrorCode, ex.HelpKeyword, ex.InitializationException);
}
else if (type == typeof(ThreadAbortException))
{
Thread.ResetAbort();
_continueOnError = ContinueOnError.ErrorAndStop;
// Cannot rethrow wrapped as ThreadAbortException is sealed and has no appropriate constructor
// Stack will be lost
throw taskException;
}
else if (type == typeof(BuildAbortedException))
{
_continueOnError = ContinueOnError.ErrorAndStop;
// Rethrow wrapped in order to avoid losing the callstack
throw new BuildAbortedException(taskException.Message, ((BuildAbortedException)taskException));
}
else if (type == typeof(CircularDependencyException))
{
_continueOnError = ContinueOnError.ErrorAndStop;
ProjectErrorUtilities.ThrowInvalidProject(taskLoggingContext.Task.Location, "CircularDependency", taskLoggingContext.TargetLoggingContext.Target.Name);
}
else if (type == typeof(InvalidProjectFileException))
{
// Just in case this came out of a task, make sure it's not
// marked as having been logged.
InvalidProjectFileException ipex = (InvalidProjectFileException)taskException;
ipex.HasBeenLogged = false;
if (_continueOnError != ContinueOnError.ErrorAndStop)
{
taskLoggingContext.LogInvalidProjectFileError(ipex);
taskLoggingContext.LogComment(MessageImportance.Normal, "ErrorConvertedIntoWarning");
}
else
{
// Rethrow wrapped in order to avoid losing the callstack
throw new InvalidProjectFileException(ipex.Message, ipex);
}
}
else if (type == typeof(Exception) || type.IsSubclassOf(typeof(Exception)))
{
// Occasionally, when debugging a very uncommon task exception, it is useful to loop the build with
// a debugger attached to break on 2nd chance exceptions.
// That requires that there needs to be a way to not catch here, by setting an environment variable.
if (ExceptionHandling.IsCriticalException(taskException) || (Environment.GetEnvironmentVariable("MSBUILDDONOTCATCHTASKEXCEPTIONS") == "1"))
{
// Wrapping in an Exception will unfortunately mean that this exception would fly through any IsCriticalException above.
// However, we should not have any, also we should not have stashed such an exception anyway.
throw new Exception(taskException.Message, taskException);
}
Exception exceptionToLog = taskException;
if (exceptionToLog is TargetInvocationException)
{
exceptionToLog = exceptionToLog.InnerException;
}
// handle any exception thrown by the task during execution
// NOTE: We catch ALL exceptions here, to attempt to completely isolate the Engine
// from failures in the task.
if (_continueOnError == ContinueOnError.WarnAndContinue)
{
taskLoggingContext.LogTaskWarningFromException
(
new BuildEventFileInfo(_targetChildInstance.Location),
exceptionToLog,
_taskNode.Name
);
// Log a message explaining why we converted the previous error into a warning.
taskLoggingContext.LogComment(MessageImportance.Normal, "ErrorConvertedIntoWarning");
}
else
{
taskLoggingContext.LogFatalTaskError
(
new BuildEventFileInfo(_targetChildInstance.Location),
exceptionToLog,
_taskNode.Name
);
}
}
else
{
ErrorUtilities.ThrowInternalErrorUnreachable();
}
}
// If the task returned attempt to gather its outputs. If gathering outputs fails set the taskResults
// to false
if (taskReturned)
{
taskResult = GatherTaskOutputs(taskExecutionHost, howToExecuteTask, bucket) && taskResult;
}
// If the taskResults are false look at ContinueOnError. If ContinueOnError=false (default)
// mark the taskExecutedSuccessfully=false. Otherwise let the task succeed but log a normal
// pri message that says this task is continuing because ContinueOnError=true
resultCode = taskResult ? WorkUnitResultCode.Success : WorkUnitResultCode.Failed;
actionCode = WorkUnitActionCode.Continue;
if (resultCode == WorkUnitResultCode.Failed)
{
if (_continueOnError == ContinueOnError.ErrorAndStop)
{
actionCode = WorkUnitActionCode.Stop;
}
else
{
// This is the ErrorAndContinue or WarnAndContinue case...
string settingString = "true";
if (_taskNode.ContinueOnErrorLocation != null)
{
settingString = bucket.Expander.ExpandIntoStringAndUnescape(_taskNode.ContinueOnError, ExpanderOptions.ExpandAll, _taskNode.ContinueOnErrorLocation); // expand embedded item vectors after expanding properties and item metadata
}
taskLoggingContext.LogComment
(
MessageImportance.Normal,
"TaskContinuedDueToContinueOnError",
"ContinueOnError",
_taskNode.Name,
settingString
);
actionCode = WorkUnitActionCode.Continue;
}
}
}
WorkUnitResult result = new WorkUnitResult(resultCode, actionCode, null);
return result;
}
/// <summary>
/// Shuts down the component.
/// </summary>
public void ShutdownComponent()
{
lock (_taskExecutionHostSync)
{
ErrorUtilities.VerifyThrow(_taskExecutionHost != null, "taskExecutionHost not initialized.");
_componentHost = null;
IDisposable disposable = _taskExecutionHost as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
_taskExecutionHost = null;
}
}
/// <summary>
/// Sets the build component host.
/// </summary>
/// <param name="host">The component host.</param>
public void InitializeComponent(IBuildComponentHost host)
{
_componentHost = host;
_taskExecutionHost = new TaskExecutionHost(host);
}
