/// <summary> /// The constructor obtains the state information and the /// callback delegate. /// </summary> internal TaskExecutionState ( TaskExecutionMode howToExecuteTask, Lookup lookupForInference, Lookup lookupForExecution, XmlElement taskXmlNode, ITaskHost hostObject, string projectFileOfTaskNode, string parentProjectFullFileName, string executionDirectory, int handleId, BuildEventContext buildEventContext ) { ErrorUtilities.VerifyThrow(taskXmlNode != null, "Must have task node"); this.howToExecuteTask = howToExecuteTask; this.lookupForInference = lookupForInference; this.lookupForExecution = lookupForExecution; this.hostObject = hostObject; this.projectFileOfTaskNode = projectFileOfTaskNode; this.parentProjectFullFileName = parentProjectFullFileName; this.executionDirectory = executionDirectory; this.handleId = handleId; this.buildEventContext = buildEventContext; this.taskXmlNode = taskXmlNode; }
/// <summary> /// Creates an instance of this class for the specified task. /// </summary> public TaskEngine ( XmlElement taskNodeXmlElement, ITaskHost hostObject, string projectFileOfTaskNode, string parentProjectFullFileName, EngineLoggingServices loggingServices, int handleId, TaskExecutionModule parentModule, BuildEventContext targetBuildEventContext ) { ErrorUtilities.VerifyThrow(taskNodeXmlElement != null, "Need to specify the task node."); ErrorUtilities.VerifyThrow(projectFileOfTaskNode != null, "Need to specify path of project."); ErrorUtilities.VerifyThrow(parentProjectFullFileName != null, "Need to specify name of project."); ErrorUtilities.VerifyThrow(loggingServices != null, "Need to specify the node logger."); this.taskNode = taskNodeXmlElement; this.taskClass = null; this.hostObject = hostObject; this.projectFileOfTaskNode = projectFileOfTaskNode; this.parentProjectFullFileName = parentProjectFullFileName; this.loggingServices = loggingServices; this.handleId = handleId; this.parentModule = parentModule; this.continueOnError = false; this.conditionAttribute = taskNode.Attributes[XMakeAttributes.condition]; this.buildEventContext = targetBuildEventContext; }
internal void InitializeHostObjectSupportForNewSwitches(ITaskHost hostObject, ref string param) { var compilerOptionsHostObject = hostObject as ICompilerOptionsHostObject; if (compilerOptionsHostObject != null) { var commandLineBuilder = new CommandLineBuilderExtension(); AddResponseFileCommandsForSwitchesSinceInitialReleaseThatAreNeededByTheHost(commandLineBuilder); param = "CompilerOptions"; CheckHostObjectSupport(param, compilerOptionsHostObject.SetCompilerOptions(commandLineBuilder.ToString())); } }
/// <summary> /// Gets any host object applicable to this task name /// where the task appears within a target and project with the specified names. /// If no host object exists, returns null. /// </summary> public ITaskHost GetHostObject(string projectFile, string targetName, string taskName) { ErrorUtilities.VerifyThrowArgumentNull(projectFile, "projectFile"); ErrorUtilities.VerifyThrowArgumentNull(targetName, "targetName"); ErrorUtilities.VerifyThrowArgumentNull(taskName, "taskName"); HostObjects hostObjects; if (_hostObjectMap == null || !_hostObjectMap.TryGetValue(projectFile, out hostObjects)) { return(null); } ITaskHost hostObject = hostObjects.GetAnyMatchingHostObject(targetName, taskName); return(hostObject); }
private static void UpdateTaskOutProcess(string taskToken, TaskCommand taskCommand) { EndpointAddress endpointAddress = new EndpointAddress(string.Format(CultureInfo.InvariantCulture, longRunningTaskAddressBase, taskToken)); NetNamedPipeBinding binding = new NetNamedPipeBinding(); ITaskHost host = ChannelFactory <ITaskHost> .CreateChannel(binding, endpointAddress); IContextChannel channel = (IContextChannel)host; channel.OperationTimeout = TimeSpan.MaxValue; try { host.UpdateTask(taskCommand); } catch (Exception e) { GisEditor.LoggerManager.Log(LoggerLevel.Debug, e.Message, new ExceptionInfo(e)); } }
public static bool Execute(string accountName, string accountKey, string connectionString, string containerName, string blobName, IBuildEngine buildengine, ITaskHost taskHost) { DeleteAzureBlob deleteAzureoBlob = new DeleteAzureBlob() { AccountName = accountName, AccountKey = accountKey, ContainerName = containerName, BlobName = blobName, BuildEngine = buildengine, HostObject = taskHost }; return(deleteAzureoBlob.Execute()); }
/// <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) { 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); return taskEngine.ExecuteTask ( TaskExecutionMode.ExecuteTaskAndGatherOutputs, new Lookup(parentProject.evaluatedItemsByName, parentProject.evaluatedProperties, ParentProject.ItemDefinitionLibrary) ); }
public static string [] Execute(string accountName, string accountKey, string connectionString, string containerName, string filterBlobNames, IBuildEngine buildengine, ITaskHost taskHost) { ListAzureBlobs getAzureBlobList = new ListAzureBlobs() { AccountName = accountName, AccountKey = accountKey, ContainerName = containerName, FilterBlobNames = filterBlobNames, BuildEngine = buildengine, HostObject = taskHost }; getAzureBlobList.Execute(); return(getAzureBlobList.BlobNames); }
public static Task <bool> ExecuteAsync(string accountName, string accountKey, string connectionString, string containerName, string blobName, string downloadDirectory, IBuildEngine buildengine, ITaskHost taskHost) { DownloadBlobFromAzure downloadBlobFromAzure = new DownloadBlobFromAzure() { AccountName = accountName, AccountKey = accountKey, ContainerName = containerName, BlobName = blobName, DownloadDirectory = downloadDirectory, BuildEngine = buildengine, HostObject = taskHost }; return(downloadBlobFromAzure.ExecuteAsync()); }
public static Task <bool> ExecuteAsync(string accountName, string accountKey, string connectionString, string containerName, string sourceBlobName, string destinationBlobName, IBuildEngine buildengine, ITaskHost taskHost) { CopyAzureBlobToBlob copyAzureBlobToBlob = new CopyAzureBlobToBlob() { AccountName = accountName, AccountKey = accountKey, ContainerName = containerName, SourceBlobName = sourceBlobName, DestinationBlobName = destinationBlobName, BuildEngine = buildengine, HostObject = taskHost }; return(copyAzureBlobToBlob.ExecuteAsync()); }
public static bool Execute(string accountName, string accountKey, string connectionString, string containerName, string blobName, string content, string contentType, IBuildEngine buildengine, ITaskHost taskHost) { PublishStringToAzureBlob publishStringToBlob = new PublishStringToAzureBlob() { AccountName = accountName, AccountKey = accountKey, ContainerName = containerName, BlobName = blobName, Content = content, ContentType = contentType, BuildEngine = buildengine, HostObject = taskHost }; return(publishStringToBlob.Execute()); }
/// <summary> /// Initializes a new instance of the <see cref="ItemOccurenceProvider"/> class. /// </summary> /// <param name="lifetime">The lifetime.</param> /// <param name="taskHost">The task host.</param> /// <param name="shellLocks">The shell locks.</param> public ItemOccurenceProvider([NotNull] Lifetime lifetime, [NotNull] ITaskHost taskHost, [NotNull] IShellLocks shellLocks) { this.myLifetime = lifetime; this.myTaskHost = taskHost; this.myShellLocks = shellLocks; }
internal TaskExecutionStateHelper ( TaskExecutionMode howToExecuteTask, Lookup lookupForInference, Lookup lookupForExecution, XmlElement taskXmlNode, ITaskHost hostObject, string projectFileOfTaskNode, string parentProjectFullFileName, string executionDirectory, int nodeProxyId ) : base(howToExecuteTask, lookupForInference, lookupForExecution, taskXmlNode, hostObject, projectFileOfTaskNode, parentProjectFullFileName, executionDirectory, nodeProxyId, null ) { // Dont need to do anything }
public void RegisterHostObject(string projectFile, string targetName, string taskName, ITaskHost hostObject) { throw new NotImplementedException(); }
public void RegisterHostObject (string projectFile, string targetName, string taskName, ITaskHost hostObject) { throw new NotImplementedException (); }
/// <summary> /// Register a host object for a particular task/target pair. /// Overwrites any existing host object. /// </summary> public void RegisterHostObject(string projectFile, string targetName, string taskName, ITaskHost hostObject) { ErrorUtilities.VerifyThrowArgumentNull(projectFile, "projectFile"); ErrorUtilities.VerifyThrowArgumentNull(targetName, "targetName"); ErrorUtilities.VerifyThrowArgumentNull(taskName, "taskName"); // We can only set the host object to a non-null value if the affinity for the project is not out of proc, or if it is, it is only implicitly // out of proc, in which case it will become in-proc after this call completes. See GetNodeAffinity. bool isExplicit; bool hasExplicitOutOfProcAffinity = (GetNodeAffinity(projectFile, out isExplicit) == NodeAffinity.OutOfProc) && (isExplicit == true); ErrorUtilities.VerifyThrowInvalidOperation(!hasExplicitOutOfProcAffinity || hostObject == null, "InvalidHostObjectOnOutOfProcProject"); _hostObjectMap = _hostObjectMap ?? new Dictionary <string, HostObjects>(StringComparer.OrdinalIgnoreCase); HostObjects hostObjects; if (!_hostObjectMap.TryGetValue(projectFile, out hostObjects)) { hostObjects = new HostObjects(); _hostObjectMap[projectFile] = hostObjects; } hostObjects.RegisterHostObject(targetName, taskName, hostObject); }
private void RunTaskOutProcess(TaskPlugin plugin, string taskToken) { string waitHandleId = Guid.NewGuid().ToString(); EventWaitHandle waitHandle = new EventWaitHandle(false, EventResetMode.ManualReset, waitHandleId); Task.Factory.StartNew(() => { string address = string.Format(longRunningTaskAddressBase, taskToken); #if GISEditorUnitTest string exePath = Assembly.GetExecutingAssembly().Location; #else string exePath = Assembly.GetEntryAssembly().Location; #endif string exeDirectory = Path.GetDirectoryName(exePath); ProcessStartInfo info = new ProcessStartInfo { CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Hidden, Arguments = string.Format(CultureInfo.InvariantCulture, argumentFormatString, waitHandleId, address, callBackReceiverAddress, taskToken), WorkingDirectory = exeDirectory, FileName = "GisEditorTaskHost" }; Process hostProcess = Process.Start(info); waitHandle.WaitOne(); EndpointAddress endpointAddress = new EndpointAddress(string.Format(CultureInfo.InvariantCulture, longRunningTaskAddressBase, taskToken)); NetNamedPipeBinding binding = new NetNamedPipeBinding(); binding.ReaderQuotas.MaxBytesPerRead = int.MaxValue; binding.ReaderQuotas.MaxDepth = int.MaxValue; binding.ReaderQuotas.MaxStringContentLength = int.MaxValue; binding.ReaderQuotas.MaxArrayLength = int.MaxValue; binding.ReceiveTimeout = TimeSpan.MaxValue; binding.MaxReceivedMessageSize = int.MaxValue; ITaskHost host = ChannelFactory <ITaskHost> .CreateChannel(binding, endpointAddress); IContextChannel channel = (IContextChannel)host; channel.OperationTimeout = TimeSpan.MaxValue; try { string tempParameterPathFileName = Path.Combine(GisEditor.InfrastructureManager.TemporaryPath, "TaskParameters", taskToken + ".setting"); string tempParameterPathName = Path.GetDirectoryName(tempParameterPathFileName); if (File.Exists(tempParameterPathFileName)) { File.Delete(tempParameterPathFileName); } else if (!Directory.Exists(tempParameterPathName)) { Directory.CreateDirectory(tempParameterPathName); } using (var pluginStream = new MemoryStream()) { BinaryFormatter serializer = new BinaryFormatter(); serializer.Serialize(pluginStream, plugin); File.WriteAllBytes(tempParameterPathFileName, pluginStream.ToArray()); } if (File.Exists(tempParameterPathFileName)) { host.RunTask(Encoding.UTF8.GetBytes(tempParameterPathFileName)); } } catch (Exception e) { GisEditor.LoggerManager.Log(LoggerLevel.Debug, e.Message, new ExceptionInfo(e)); } }); }
public GotoWordIndexProvider([NotNull] Lifetime lifetime, [NotNull] ITaskHost taskHost, [NotNull] IShellLocks shellLocks) { myLifetime = lifetime; myTaskHost = taskHost; myShellLocks = shellLocks; }
/// <summary> /// Cleans up after running the task. /// </summary> void ITaskExecutionHost.CleanupForTask() { if (_resolver != null) { _resolver.RemoveHandler(); _resolver = null; } _taskFactoryWrapper = null; // We must null this out because it could be a COM object (or any other ref-counted object) which needs to // be released. _taskHost = null; CleanupCancellationToken(); ErrorUtilities.VerifyThrow(_taskInstance == null, "Task Instance should be null"); }
/// <summary> /// Create a TaskExecutionState structure which contains all the information necessary /// to execute the task and send this information over to the TEM for task execution /// </summary> internal void SubmitNonIntrinsicTask ( XmlElement taskNode, ITaskHost hostObject, ProjectBuildState buildContext ) { if (!haveRunANonIntrinsicTask) { InitializeForRunningFirstNonIntrinsicTask(); haveRunANonIntrinsicTask = true; } TaskExecutionMode executionMode = DetermineExecutionMode(); // A TaskExecutionMode of ExecuteTaskAndGatherOutputs should have its messages logged in the context of the task and therefore should have a valid taskID // A TaskExecutionMode of InferOutputs or Invalid should have its messages logged in the context of the target and therefore should have an invalid taskID BuildEventContext buildEventContext = PrepareBuildEventContext(executionMode == TaskExecutionMode.ExecuteTaskAndGatherOutputs ? false: true); // Create the task execution context int handleId = parentEngine.EngineCallback.CreateTaskContext(parentProject, targetClass, buildContext, taskNode, EngineCallback.inProcNode, buildEventContext); // Create the task execution state TaskExecutionState taskState = new TaskExecutionState ( executionMode, lookupForInference, lookupForExecution, taskNode, hostObject, projectFileOfTaskNode, parentProject.FullFileName, parentProject.ProjectDirectory, handleId, buildEventContext ); // Send the request for task execution to the node parentEngine.NodeManager.ExecuteTask(taskState); }
public MonikerNameOrITaskHost(ITaskHost taskHost) { TaskHost = taskHost; IsTaskHost = true; }
/// <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 LocateFileController([NotNull] Lifetime lifetime, [NotNull] ISolution solution, [NotNull] IShellLocks locks, ITaskHost tasks, bool enableMulticore = false) : base(lifetime, solution, locks, tasks, enableMulticore) { Model.CaptionText.Value = "Enter file or folder name to locate:"; }
public void RegisterHostObject (string projectFile, string targetName, string taskName, ITaskHost hostObject) { if (hostObject == null) throw new ArgumentNullException ("hostObject"); var reg = GetHostRegistration (projectFile, targetName, taskName); if (reg != null) reg.HostObject = hostObject; else hosts.Add (new HostObjectRegistration () { ProjectFile = projectFile, TargetName = targetName, TaskName = taskName, HostObject = hostObject }); }
/// <summary> /// Register a host object for a particular task/target pair. /// Overwrites any existing host object. /// </summary> public void RegisterHostObject(string projectFile, string targetName, string taskName, ITaskHost hostObject) { /* Unmerged change from project 'Microsoft.Build (netcoreapp2.1)' * Before: * ErrorUtilities.VerifyThrowArgumentNull(projectFile, "projectFile"); * ErrorUtilities.VerifyThrowArgumentNull(targetName, "targetName"); * After: * ErrorUtilities.VerifyThrowArgumentNull(projectFile, "projectFile)); * ErrorUtilities.VerifyThrowArgumentNull(targetName, "targetName)); */ ErrorUtilities.VerifyThrowArgumentNull(projectFile, nameof(projectFile)); ErrorUtilities.VerifyThrowArgumentNull(targetName, nameof(targetName)); ErrorUtilities.VerifyThrowArgumentNull(taskName, nameof(taskName)); // We can only set the host object to a non-null value if the affinity for the project is not out of proc, or if it is, it is only implicitly // out of proc, in which case it will become in-proc after this call completes. See GetNodeAffinity. bool isExplicit; bool hasExplicitOutOfProcAffinity = (GetNodeAffinity(projectFile, out isExplicit) == NodeAffinity.OutOfProc) && isExplicit; ErrorUtilities.VerifyThrowInvalidOperation(!hasExplicitOutOfProcAffinity || hostObject == null, "InvalidHostObjectOnOutOfProcProject"); _hostObjectMap ??= new Dictionary <string, HostObjects>(StringComparer.OrdinalIgnoreCase); HostObjects hostObjects = GetHostObjectsFromMapByKeyOrCreateNew(projectFile); hostObjects.RegisterHostObject(targetName, taskName, hostObject); }
public void RegisterHostObject(string projectFile, string targetName, string taskName, ITaskHost hostObject) { if (hostObject == null) { throw new ArgumentNullException("hostObject"); } var reg = GetHostRegistration(projectFile, targetName, taskName); if (reg != null) { reg.HostObject = hostObject; } else { hosts.Add(new HostObjectRegistration() { ProjectFile = projectFile, TargetName = targetName, TaskName = taskName, HostObject = hostObject }); } }
/// <summary> /// Builds the task specified by the XML. /// </summary> /// <param name="loggingContext">The logging context of the target</param> /// <param name="requestEntry">The build request entry being built</param> /// <param name="targetBuilderCallback">The target builder callback.</param> /// <param name="taskInstance">The task instance.</param> /// <param name="mode">The mode in which to execute tasks.</param> /// <param name="inferLookup">The lookup to be used for inference.</param> /// <param name="executeLookup">The lookup to be used during execution.</param> /// <returns>The result of running the task batch.</returns> /// <remarks> /// The ExecuteTask method takes a task as specified by XML and executes it. This procedure is comprised /// of the following steps: /// 1. Loading the Task from its containing assembly by looking it up in the task registry /// 2. Determining if the task is batched. If it is, create the batches and execute each as if it were a non-batched task /// 3. If the task is not batched, execute it. /// 4. If the task was batched, hold on to its Lookup until all of the natches are done, then merge them. /// </remarks> public async Task<WorkUnitResult> ExecuteTask(TargetLoggingContext loggingContext, BuildRequestEntry requestEntry, ITargetBuilderCallback targetBuilderCallback, ProjectTargetInstanceChild taskInstance, TaskExecutionMode mode, Lookup inferLookup, Lookup executeLookup, CancellationToken cancellationToken) { ErrorUtilities.VerifyThrow(taskInstance != null, "Need to specify the task instance."); _buildRequestEntry = requestEntry; _targetBuilderCallback = targetBuilderCallback; _cancellationToken = cancellationToken; _targetChildInstance = taskInstance; // In the case of Intrinsic tasks, taskNode will end up null. Currently this is how we distinguish // intrinsic from extrinsic tasks. _taskNode = taskInstance as ProjectTaskInstance; if (_taskNode != null && requestEntry.Request.HostServices != null) { _taskHostObject = requestEntry.Request.HostServices.GetHostObject(requestEntry.RequestConfiguration.Project.FullPath, loggingContext.Target.Name, _taskNode.Name); } _projectFullPath = requestEntry.RequestConfiguration.Project.FullPath; // this.handleId = handleId; No handles // this.parentModule = parentModule; No task execution module _continueOnError = ContinueOnError.ErrorAndStop; _targetLoggingContext = loggingContext; WorkUnitResult taskResult = new WorkUnitResult(WorkUnitResultCode.Failed, WorkUnitActionCode.Stop, null); if ((mode & TaskExecutionMode.InferOutputsOnly) == TaskExecutionMode.InferOutputsOnly) { taskResult = await ExecuteTask(TaskExecutionMode.InferOutputsOnly, inferLookup); } if ((mode & TaskExecutionMode.ExecuteTaskAndGatherOutputs) == TaskExecutionMode.ExecuteTaskAndGatherOutputs) { taskResult = await ExecuteTask(TaskExecutionMode.ExecuteTaskAndGatherOutputs, executeLookup); } return taskResult; }
public GotoWordIndexController([NotNull] Lifetime lifetime, [NotNull] ISolution solution, LibrariesFlag librariesFlag, [NotNull] IShellLocks locks, [NotNull] ITaskHost taskHost) : base(lifetime, solution, solution, librariesFlag, locks, taskHost, enableMulticore: false) #endif { var manager = GotoByNameModelManager.GetInstance(solution); manager.ProcessModel <GotoWordModelInitializer>(Model, lifetime); }
/// <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; }