/// <summary> /// Executes a task within a target. This method initializes a task engine for the given task, and then executes the task /// using the engine. /// </summary> /// <param name="taskNode"></param> /// <param name="hostObject"></param> /// <returns>true, if successful</returns> internal bool ExecuteOneTask(XmlElement taskNode, ITaskHost hostObject) { bool taskExecutedSuccessfully = false; string projectFileOfTaskNode = XmlUtilities.GetXmlNodeFile(taskNode, parentProject.FullFileName); BuildEventContext targetBuildEventContext = new BuildEventContext ( ParentProject.ProjectBuildEventContext.NodeId, this.id, ParentProject.ProjectBuildEventContext.ProjectContextId, ParentProject.ProjectBuildEventContext.TaskId ); int handleId = parentEngine.EngineCallback.CreateTaskContext(ParentProject, this, null, taskNode, EngineCallback.inProcNode, targetBuildEventContext); TaskExecutionModule taskExecutionModule = parentEngine.NodeManager.TaskExecutionModule; TaskEngine taskEngine = new TaskEngine(taskNode, hostObject, parentProject.FullFileName, projectFileOfTaskNode, parentEngine.LoggingServices, handleId, taskExecutionModule, targetBuildEventContext); taskExecutedSuccessfully = taskEngine.ExecuteTask ( TaskExecutionMode.ExecuteTaskAndGatherOutputs, new Lookup(parentProject.evaluatedItemsByName, parentProject.evaluatedProperties, ParentProject.ItemDefinitionLibrary) ); return(taskExecutedSuccessfully); }
public void SetUp() { // Whole bunch of setup code. XmlElement taskNode = new XmlDocument().CreateElement("MockTask"); LoadedType taskClass = new LoadedType(typeof(MockTask), new AssemblyLoadInfo(typeof(MockTask).Assembly.FullName, null)); engine = new Engine(@"c:\"); Project project = new Project(engine); EngineCallback engineCallback = new EngineCallback(engine); taskExecutionModule = new MockTaskExecutionModule(engineCallback); int handleId = engineCallback.CreateTaskContext(project, null, null, taskNode, EngineCallback.inProcNode, new BuildEventContext(BuildEventContext.InvalidNodeId, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidProjectContextId, BuildEventContext.InvalidTaskId)); TaskEngine taskEngine = new TaskEngine ( taskNode, null, /* host object */ "In Memory", project.FullFileName, engine.LoggingServices, handleId, taskExecutionModule, null ); taskEngine.TaskClass = taskClass; engineProxy = new EngineProxy(taskExecutionModule, handleId, project.FullFileName, project.FullFileName, engine.LoggingServices, null); taskExecutionModule2 = new MockTaskExecutionModule(engineCallback, TaskExecutionModule.TaskExecutionModuleMode.MultiProcFullNodeMode); engineProxy2 = new EngineProxy(taskExecutionModule2, handleId, project.FullFileName, project.FullFileName, engine.LoggingServices, null); }
public bool Execute() { TaskEngine taskEngine; LogTaskStarted(); ITask task; try { task = InitializeTask(); } catch (Exception e) { LogError("Error initializing task {0}: {1}", taskElement.LocalName, e.Message); LogMessage(MessageImportance.Low, "Error initializing task {0}: {1}", taskElement.LocalName, e.ToString()); return(false); } try { taskEngine = new TaskEngine(parentTarget.Project, task, Type); taskEngine.Prepare(GetParameters()); var result = taskEngine.Execute(); if (result) { taskEngine.PublishOutput(taskElement, taskEngine.ValueFromExecution); } LogTaskFinished(result); return(result); } catch (Exception e) { task_logger.LogError("Error executing task {0}: {1}", taskElement.LocalName, e.Message); task_logger.LogMessage(MessageImportance.Low, "Error executing task {0}: {1}", taskElement.LocalName, e.ToString()); return(false); } }
/// <summary> /// Since we could not derrive from TaskEngine and have no Interface, we need to overide the method in here and /// replace the calls when testing the class because of the calls to TaskEngine. If at a future time we get a mock task /// engine, Interface or a non sealed TaskEngine these methods can disappear. /// </summary> /// <returns></returns> virtual internal bool TaskEngineExecuteTask( TaskEngine taskEngine, TaskExecutionMode howTaskShouldBeExecuted, Lookup lookup ) { return(taskEngine.ExecuteTask ( howTaskShouldBeExecuted, lookup )); }
bool IBuildTask.ResolveOutputItems() { var taskEngine = new TaskEngine(parentTarget.Project, null, Type); taskEngine.PublishOutput(taskElement, l => { var pv = GetParameterValue(l.Name); Expression exp = new Expression(); exp.Parse(pv, ParseOptions.AllowItemsNoMetadataAndSplit); return(exp.ConvertTo(parentTarget.Project, l.PropertyType)); }); return(true); }
public bool Execute() { bool result = false; TaskEngine taskEngine; LogTaskStarted(); ITask task = null; try { try { task = InitializeTask(); } catch (Exception e) { LogError("Error initializing task {0}: {1}", taskElement.LocalName, e.Message); LogMessage(MessageImportance.Low, "Error initializing task {0}: {1}", taskElement.LocalName, e.ToString()); return(false); } try { taskEngine = new TaskEngine(parentTarget.Project); taskEngine.Prepare(task, this.taskElement, GetParameters(), this.Type); result = taskEngine.Execute(); if (result) { taskEngine.PublishOutput(); } } catch (Exception e) { task_logger.LogError("Error executing task {0}: {1}", taskElement.LocalName, e.Message); task_logger.LogMessage(MessageImportance.Low, "Error executing task {0}: {1}", taskElement.LocalName, e.ToString()); result = false; } } finally { LogTaskFinished(result); } return(result); }
public bool Execute () { bool result = false; TaskEngine taskEngine; LogTaskStarted (); ITask task = null; try { try { task = InitializeTask (); } catch (Exception e) { LogError ("Error initializing task {0}: {1}", taskElement.LocalName, e.Message); LogMessage (MessageImportance.Low, "Error initializing task {0}: {1}", taskElement.LocalName, e.ToString ()); return false; } try { taskEngine = new TaskEngine (parentTarget.Project); taskEngine.Prepare (task, this.taskElement, GetParameters (), this.Type); result = taskEngine.Execute (); if (result) taskEngine.PublishOutput (); } catch (Exception e) { task_logger.LogError ("Error executing task {0}: {1}", taskElement.LocalName, e.Message); task_logger.LogMessage (MessageImportance.Low, "Error executing task {0}: {1}", taskElement.LocalName, e.ToString ()); result = false; } } finally { LogTaskFinished (result); } return result; }
/// <summary> /// Executes a task within a target. This method initializes a task engine for the given task, and then executes the task /// using the engine. /// </summary> /// <param name="taskNode"></param> /// <param name="hostObject"></param> /// <returns>true, if successful</returns> internal bool ExecuteOneTask(XmlElement taskNode, ITaskHost hostObject) { bool taskExecutedSuccessfully = false; string projectFileOfTaskNode = XmlUtilities.GetXmlNodeFile(taskNode, parentProject.FullFileName); BuildEventContext targetBuildEventContext = new BuildEventContext ( ParentProject.ProjectBuildEventContext.NodeId, this.id, ParentProject.ProjectBuildEventContext.ProjectContextId, ParentProject.ProjectBuildEventContext.TaskId ); int handleId = parentEngine.EngineCallback.CreateTaskContext(ParentProject,this, null, taskNode, EngineCallback.inProcNode, targetBuildEventContext); TaskExecutionModule taskExecutionModule = parentEngine.NodeManager.TaskExecutionModule; TaskEngine taskEngine = new TaskEngine(taskNode, hostObject, parentProject.FullFileName, projectFileOfTaskNode, parentEngine.LoggingServices, handleId, taskExecutionModule, targetBuildEventContext); taskExecutedSuccessfully = taskEngine.ExecuteTask ( TaskExecutionMode.ExecuteTaskAndGatherOutputs, new Lookup(parentProject.evaluatedItemsByName, parentProject.evaluatedProperties, ParentProject.ItemDefinitionLibrary) ); return taskExecutedSuccessfully; }
/// <summary> /// Mock out and override the method inside of TaskExecutionState which makes the calls to the task engine. /// </summary> internal override bool TaskEngineExecuteTask(TaskEngine taskEngine, TaskExecutionMode howToExecuteTask, Lookup lookup) { return targetInferenceSuccessful; }
/// <summary> /// Creates an instance of a MockTask, and returns the objects necessary to exercise /// taskEngine.InitializeTask /// </summary> /// <param name="taskNode"></param> /// <param name="taskEngine"></param> /// <param name="mockTask"></param> /// <param name="itemBucket"></param> /// <owner>RGoel</owner> private void InstantiateMockTaskHelper ( XmlElement taskNode, out TaskEngine taskEngine, out MockTask mockTask, out ItemBucket itemBucket, out EngineProxy engineProxy, string condition ) { LoadedType taskClass = new LoadedType(typeof(MockTask), new AssemblyLoadInfo(typeof(MockTask).Assembly.FullName, null)); Engine engine = new Engine(@"c:\"); Project project = new Project(engine); EngineCallback engineCallback = new EngineCallback(engine); TaskExecutionModule taskExecutionModule = new TaskExecutionModule(engineCallback, TaskExecutionModule.TaskExecutionModuleMode.SingleProcMode, false); ProjectBuildState buildContext = new ProjectBuildState(null, null, new BuildEventContext(0, 1, 1, 1)); int nodeProxyID = engineCallback.CreateTaskContext(project, null, buildContext, taskNode, EngineCallback.inProcNode, new BuildEventContext(BuildEventContext.InvalidNodeId, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidProjectContextId, BuildEventContext.InvalidTaskId)); taskEngine = new TaskEngine ( taskNode, null, /* host object */ "In Memory", project.FullFileName, engine.LoggingServices, nodeProxyID, taskExecutionModule, new BuildEventContext(0, 1, 1, 1) ); taskEngine.TaskClass = taskClass; engineProxy = new EngineProxy(taskExecutionModule, nodeProxyID, project.FullFileName, project.FullFileName, engine.LoggingServices, null); mockTask = new MockTask(new EngineProxy(taskExecutionModule, nodeProxyID, project.FullFileName, project.FullFileName, engine.LoggingServices, null)); // The code below creates an item table that is equivalent to the following MSBuild syntax: // // <ItemGroup> // <ItemListContainingOneItem Include="a.cs"> // <Culture>fr-fr</Culture> // </ItemListContainingOneItem> // // <ItemListContainingTwoItems Include="b.cs"> // <HintPath>c:\foo</HintPath> // </ItemListContainingTwoItems> // <ItemListContainingTwoItems Include="c.cs"> // <HintPath>c:\bar</HintPath> // </ItemListContainingTwoItems> // </ItemGroup> // Hashtable itemsByName = new Hashtable(StringComparer.OrdinalIgnoreCase); BuildItemGroup itemListContainingOneItem = new BuildItemGroup(); BuildItem a = itemListContainingOneItem.AddNewItem("ItemListContainingOneItem", "a.cs"); a.SetMetadata("Culture", "fr-fr"); itemsByName["ItemListContainingOneItem"] = itemListContainingOneItem; BuildItemGroup itemListContainingTwoItems = new BuildItemGroup(); BuildItem b = itemListContainingTwoItems.AddNewItem("ItemListContainingTwoItems", "b.cs"); b.SetMetadata("HintPath", "c:\\foo"); BuildItem c = itemListContainingTwoItems.AddNewItem("ItemListContainingTwoItems", "c.cs"); c.SetMetadata("HintPath", "c:\\bar"); itemsByName["ItemListContainingTwoItems"] = itemListContainingTwoItems; itemBucket = new ItemBucket(new string[0], new Dictionary<string, string>(), LookupHelpers.CreateLookup(itemsByName), 0); }
/********************************************************************************* * * Helpers * *********************************************************************************/ private void InstantiateMockTaskHelper ( XmlElement taskNode, out TaskEngine taskEngine, out MockTask mockTask, out ItemBucket itemBucket, out EngineProxy engineProxy ) { InstantiateMockTaskHelper(taskNode, out taskEngine, out mockTask, out itemBucket, out engineProxy, null); }
/// <summary> /// Since we could not derrive from TaskEngine and have no Interface, we need to overide the method in here and /// replace the calls when testing the class because of the calls to TaskEngine. If at a future time we get a mock task /// engine, Interface or a non sealed TaskEngine these methods can disappear. /// </summary> /// <returns></returns> virtual internal bool TaskEngineExecuteTask( TaskEngine taskEngine, TaskExecutionMode howTaskShouldBeExecuted, Lookup lookup ) { return taskEngine.ExecuteTask ( howTaskShouldBeExecuted, lookup ); }
/// <summary> /// The thread procedure executes the tasks and calls callback once it is done /// </summary> virtual internal void ExecuteTask() { bool taskExecutedSuccessfully = true; Exception thrownException = null; bool dontPostOutputs = false; if (profileExecution) { startTime = DateTime.Now.Ticks; } try { TaskEngine taskEngine = new TaskEngine( taskXmlNode, hostObject, projectFileOfTaskNode, parentProjectFullFileName, loggingService, handleId, parentModule, buildEventContext); // Set the directory to the one appropriate for the task if (FileUtilities.GetCurrentDirectoryStaticBuffer(currentDirectoryBuffer) != executionDirectory) { Directory.SetCurrentDirectory(executionDirectory); } // if we're skipping task execution because the target is up-to-date, we // need to go ahead and infer all the outputs that would have been emitted; // alternatively, if we're doing an incremental build, we need to infer the // outputs that would have been produced if all the up-to-date items had // been built by the task if ((howToExecuteTask & TaskExecutionMode.InferOutputsOnly) != TaskExecutionMode.Invalid) { bool targetInferenceSuccessful = false; targetInferenceSuccessful = TaskEngineExecuteTask ( taskEngine, TaskExecutionMode.InferOutputsOnly, lookupForInference ); ErrorUtilities.VerifyThrow(targetInferenceSuccessful, "A task engine should never fail to infer its task's up-to-date outputs."); } // execute the task using the items that need to be (re)built if ((howToExecuteTask & TaskExecutionMode.ExecuteTaskAndGatherOutputs) != TaskExecutionMode.Invalid) { taskExecutedSuccessfully = TaskEngineExecuteTask ( taskEngine, TaskExecutionMode.ExecuteTaskAndGatherOutputs, lookupForExecution ); } } // We want to catch all exceptions and pass them on to the engine catch (Exception e) { thrownException = e; taskExecutedSuccessfully = false; // In single threaded mode the exception can be thrown on the current thread if (parentModule.RethrowTaskExceptions()) { dontPostOutputs = true; throw; } } finally { if (!dontPostOutputs) { long executionTime = profileExecution ? DateTime.Now.Ticks - startTime : 0; // Post the outputs to the engine parentModule.PostTaskOutputs(handleId, taskExecutedSuccessfully, thrownException, executionTime); } } }
bool IBuildTask.ResolveOutputItems () { var taskEngine = new TaskEngine (parentTarget.Project, null, Type); taskEngine.PublishOutput (taskElement, l => { var pv = GetParameterValue (l.Name); Expression exp = new Expression (); exp.Parse (pv, ParseOptions.AllowItemsNoMetadataAndSplit); return exp.ConvertTo (parentTarget.Project, l.PropertyType); }); return true; }
/// <summary> /// The thread procedure executes the tasks and calls callback once it is done /// </summary> virtual internal void ExecuteTask() { bool taskExecutedSuccessfully = true; Exception thrownException = null; bool dontPostOutputs = false; if (profileExecution) { startTime = DateTime.Now.Ticks; } try { TaskEngine taskEngine = new TaskEngine( taskXmlNode, hostObject, projectFileOfTaskNode, parentProjectFullFileName, loggingService, handleId, parentModule, buildEventContext); // Set the directory to the one appropriate for the task if (FileUtilities.GetCurrentDirectoryStaticBuffer(currentDirectoryBuffer) != executionDirectory) { Directory.SetCurrentDirectory(executionDirectory); } // if we're skipping task execution because the target is up-to-date, we // need to go ahead and infer all the outputs that would have been emitted; // alternatively, if we're doing an incremental build, we need to infer the // outputs that would have been produced if all the up-to-date items had // been built by the task if ((howToExecuteTask & TaskExecutionMode.InferOutputsOnly) != TaskExecutionMode.Invalid) { bool targetInferenceSuccessful = false; targetInferenceSuccessful = TaskEngineExecuteTask (taskEngine, TaskExecutionMode.InferOutputsOnly, lookupForInference ); ErrorUtilities.VerifyThrow(targetInferenceSuccessful, "A task engine should never fail to infer its task's up-to-date outputs."); } // execute the task using the items that need to be (re)built if ((howToExecuteTask & TaskExecutionMode.ExecuteTaskAndGatherOutputs) != TaskExecutionMode.Invalid) { taskExecutedSuccessfully = TaskEngineExecuteTask (taskEngine, TaskExecutionMode.ExecuteTaskAndGatherOutputs, lookupForExecution ); } } // We want to catch all exceptions and pass them on to the engine catch (Exception e) { thrownException = e; taskExecutedSuccessfully = false; // In single threaded mode the exception can be thrown on the current thread if (parentModule.RethrowTaskExceptions()) { dontPostOutputs = true; throw; } } finally { if (!dontPostOutputs) { long executionTime = profileExecution ? DateTime.Now.Ticks - startTime : 0; // Post the outputs to the engine parentModule.PostTaskOutputs(handleId, taskExecutedSuccessfully, thrownException, executionTime); } } }
internal EngineProxy CreateEngineProxyWithDummyTaskEngine(Engine e, Project p) { // UNDONE need a real handle Id and a real TEM pointer XmlElement taskNode = new XmlDocument().CreateElement("MockTask"); BuildRequest request = new BuildRequest(EngineCallback.invalidEngineHandle, "mockproject", null, (BuildPropertyGroup)null, null, -1, false, false); ProjectBuildState context = new ProjectBuildState(request, new ArrayList(), new BuildEventContext(0, 0, 0, 0)); int handleId = e.EngineCallback.CreateTaskContext(p, null, context, taskNode, 0, new BuildEventContext(0, 0, 0, 0)); TaskEngine taskEngine = new TaskEngine ( taskNode, null, /* host object */ p.FullFileName, p.FullFileName, e.LoggingServices, handleId, e.NodeManager.TaskExecutionModule, new BuildEventContext(0, 0, 0, 0) ); e.Scheduler.Initialize(new INodeDescription[] { null }); return new EngineProxy(e.NodeManager.TaskExecutionModule, handleId, p.FullFileName, p.FullFileName, e.LoggingServices, new BuildEventContext(0, 0, 0, 0)); }