/// <summary> /// Runs the task, given the specified <see cref="IIntegrationResult"/>, in the specified <see cref="IProject"/>. /// </summary> /// <param name="result"></param> protected override bool Execute(IIntegrationResult result) { // Initialise the task var logger = Logger ?? new DefaultLogger(); var numberOfTasks = Tasks.Length; result.BuildProgressInformation.SignalStartRunTask(GetStatusInformation(null)); logger.Info("Starting sequential task with {0} sub-task(s)", numberOfTasks); // Launch each task var successCount = 0; var failureCount = 0; for (var loop = 0; loop < numberOfTasks; loop++) { var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} [{1}]", Tasks[loop].GetType().Name, loop); logger.Debug("Starting task '{0}'", taskName); try { var taskResult = result.Clone(); // must reset the status so that we check for the current task failure and not a previous one taskResult.Status = IntegrationStatus.Unknown; // Start the actual task var task = Tasks[loop]; RunTask(task, taskResult, new RunningSubTaskDetails(loop, result)); result.Merge(taskResult); } catch (Exception error) { // Handle any error details result.ExceptionResult = error; result.Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results if (result.Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; if (!ContinueOnFailure) { break; } } } // Clean up this.CancelTasks(); logger.Info("Sequential task completed: {0} successful, {1} failed", successCount, failureCount); return(failureCount == 0); }
private static void RunTaskAndMergeResult(ITask task, IIntegrationResult result) { IIntegrationResult subResult = result.Clone(); try { task.Run(subResult); } finally { result.Merge(subResult); } }
protected override bool Execute(IIntegrationResult result) { int loop = 0; foreach (var task in Tasks) { var taskResult = result.Clone(); RunTask(task, taskResult, new RunningSubTaskDetails(loop, result)); result.Merge(taskResult); loop++; } return(true); }
private void AddResultMockExpectedClone(IIntegrationResult result) { Expect.Call(result.Clone()). Do((Func <IIntegrationResult>)(() => { var clone = mocks.StrictMock <IIntegrationResult>(); SetupResult.For(clone.BuildProgressInformation).Return(result.BuildProgressInformation); SetupResult.For(clone.Status).PropertyBehavior(); SetupResult.For(clone.ExceptionResult).PropertyBehavior(); clone.Status = result.Status; clone.Replay(); return(clone); })); }
/// <summary> /// Runs some tasks. /// </summary> /// <param name="tasks">The tasks.</param> /// <param name="logger">The logger.</param> /// <param name="runningIfTasks">true if running the "if" tasks.</param> /// <param name="result">The result.</param> /// <returns><c>true</c> if all the tasks are successul; <c>false</c> otherwise.</returns> private bool RunTasks(ITask[] tasks, ILogger logger, bool runningIfTasks, IIntegrationResult result) { // Launch each task var successCount = 0; var failureCount = 0; for (var loop = 0; loop < tasks.Length; loop++) { var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} [{1}]", tasks[loop].GetType().Name, loop); logger.Debug("Starting task '{0}'", taskName); try { var taskResult = result.Clone(); // must reset the status so that we check for the current task failure and not a previous one taskResult.Status = IntegrationStatus.Unknown; // Start the actual task var task = tasks[loop]; this.RunTask(task, taskResult, new RunningSubTaskDetails(loop, runningIfTasks, result)); result.Merge(taskResult); } catch (Exception error) { // Handle any error details result.ExceptionResult = error; result.Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results if (result.Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; if (!ContinueOnFailure) { break; } } } logger.Info("Tasks completed: {0} successful, {1} failed", successCount, failureCount); return(failureCount == 0); }
/// <summary> /// Runs the task, given the specified <see cref="IIntegrationResult"/>, in the specified <see cref="IProject"/>. /// </summary> /// <param name="result">The results of the current build.</param> /// <returns><c>true</c> if the execution is successful; <c>false</c> otherwise.</returns> protected override bool Execute(IIntegrationResult result) { // Initialise the publisher var logger = this.Logger ?? new DefaultLogger(); result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Checking conditional publishers"); logger.Info("Checking conditional publishers"); // Check the conditions var runPublishers = false; foreach (var condition in this.Conditions ?? new IntegrationStatus[0]) { runPublishers |= condition == result.Status; } if (runPublishers) { // Run each publisher logger.Info("Conditions met - running publishers"); for (var loop = 0; loop < this.Tasks.Length; loop++) { logger.Debug("Running publisher #{0}", loop); try { var taskResult = result.Clone(); var publisher = this.Tasks[loop]; RunTask(publisher, taskResult, new RunningSubTaskDetails(loop, result)); result.Merge(taskResult); } catch (Exception e) { logger.Error("Publisher threw exception: {0}", e.Message); } } } else { logger.Info("Conditions not met - publishers not run"); } // Clean up this.CancelTasks(); return(true); }
/// <summary> /// Runs some tasks. /// </summary> /// <param name="tasks">The tasks.</param> /// <param name="logger">The logger.</param> /// <param name="result">The result.</param> /// <returns><c>true</c> if all the tasks are successul; <c>false</c> otherwise.</returns> private bool RunTasks(ITask[] tasks, ILogger logger, IIntegrationResult result) { // Launch each task var successCount = 0; var failureCount = 0; for (var loop = 0; loop < tasks.Length; loop++) { var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} [{1}]", tasks[loop].GetType().Name, loop); logger.Debug("Starting task '{0}'", taskName); try { // Start the actual task var taskResult = result.Clone(); var task = tasks[loop]; this.RunTask(task, taskResult); result.Merge(taskResult); } catch (Exception error) { // Handle any error details result.ExceptionResult = error; result.Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results if (result.Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; } } logger.Info("Tasks completed: {0} successful, {1} failed", successCount, failureCount); return(failureCount == 0); }
public T RunWithRemoteResult <T>(Func <IIntegrationResult, T> action, IIntegrationResult result) { IIntegrationResult remoteResult = result.Clone(); if (RemoteArtifactDirectory != null) { remoteResult.ArtifactDirectory = RemoteArtifactDirectory; } if (RemoteWorkingDirectory != null) { remoteResult.WorkingDirectory = RemoteWorkingDirectory; } try { return(action(remoteResult)); } finally { result.Merge(remoteResult); } }
/// <summary> /// Runs some tasks. /// </summary> /// <param name="tasks">The tasks.</param> /// <param name="logger">The logger.</param> /// <param name="runningIfTasks">true if running the "if" tasks.</param> /// <param name="result">The result.</param> /// <returns><c>true</c> if all the tasks are successul; <c>false</c> otherwise.</returns> private bool RunTasks(ITask[] tasks, ILogger logger, bool runningIfTasks, IIntegrationResult result) { // Launch each task var successCount = 0; var failureCount = 0; for (var loop = 0; loop < tasks.Length; loop++) { var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture,"{0} [{1}]", tasks[loop].GetType().Name, loop); logger.Debug("Starting task '{0}'", taskName); try { // Start the actual task var taskResult = result.Clone(); var task = tasks[loop]; this.RunTask(task, taskResult, new RunningSubTaskDetails(loop, runningIfTasks, result)); result.Merge(taskResult); } catch (Exception error) { // Handle any error details result.ExceptionResult = error; result.Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results if (result.Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; if (!ContinueOnFailure) break; } } logger.Info("Tasks completed: {0} successful, {1} failed", successCount, failureCount); return failureCount == 0; }
/// <summary> /// Runs the task, given the specified <see cref="IIntegrationResult"/>, in the specified <see cref="IProject"/>. /// </summary> /// <param name="result"></param> protected override bool Execute(IIntegrationResult result) { // Initialise the task var logger = Logger ?? new DefaultLogger(); var numberOfTasks = Tasks.Length; result.BuildProgressInformation.SignalStartRunTask(_getStatusInformation("", null)); logger.Info("Starting sequential task with {0} sub-task(s)", numberOfTasks); // Launch each task var successCount = 0; var failureCount = 0; for (var loop = 0; loop < numberOfTasks; loop++) { var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture,"{0} [{1}]", Tasks[loop].GetType().Name, loop); logger.Debug("Starting task '{0}'", taskName); try { // Start the actual task var taskResult = result.Clone(); taskResult.BuildProgressInformation.OnStartupInformationUpdatedUserObject = new _RunningSubTaskDetails(loop, result); taskResult.BuildProgressInformation.OnStartupInformationUpdated = SubTaskStartupInformationUpdated; var task = Tasks[loop]; RunTask(task, taskResult); result.Merge(taskResult); } catch (Exception error) { // Handle any error details result.ExceptionResult = error; result.Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results if (result.Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; if (!ContinueOnFailure) break; } } // Clean up this.CancelTasks(); logger.Info("Sequential task completed: {0} successful, {1} failed", successCount, failureCount); return failureCount == 0; }
/// <summary> /// Execute the actual task functionality. /// </summary> /// <param name="result">The result to use.</param> /// <returns> /// True if the task was successful, false otherwise. /// </returns> protected override bool Execute(IIntegrationResult result) { // Initialise the task var logger = Logger ?? new DefaultLogger(); var numberOfTasks = Tasks.Length; result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : string.Format(System.Globalization.CultureInfo.CurrentCulture, "Running tasks in synchronisation context({0} task(s))", numberOfTasks)); logger.Info("Starting synchronisation task with {0} sub-task(s)", numberOfTasks); var contextToUse = this.ContextName ?? "DefaultSynchronisationContext"; // Make sure the context has been loaded lock (lockObject) { if (!contexts.ContainsKey(contextToUse)) { contexts.Add(contextToUse, new object()); } } // Attempt to enter the synchronisation context if (Monitor.TryEnter(contexts[contextToUse], TimeoutPeriod * 1000)) { try { // Launch each task var successCount = 0; var failureCount = 0; for (var loop = 0; loop < numberOfTasks; loop++) { var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} [{1}]", Tasks[loop].GetType().Name, loop); logger.Debug("Starting task '{0}'", taskName); try { // Start the actual task var taskResult = result.Clone(); var task = Tasks[loop]; RunTask(task, taskResult); result.Merge(taskResult); } catch (Exception error) { // Handle any error details result.ExceptionResult = error; result.Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results if (result.Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; if (!ContinueOnFailure) break; } } logger.Info("Parallel task completed: {0} successful, {1} failed", successCount, failureCount); } finally { Monitor.Exit(contexts[contextToUse]); } } else { // Set the result as failed logger.Warning("Unable to enter synchonisation context!"); result.Status = IntegrationStatus.Failure; } // Clean up this.CancelTasks(); return (result.Status == IntegrationStatus.Success); }
/// <summary> /// Execute the actual task functionality. /// </summary> /// <param name="result">The result to use.</param> /// <returns> /// True if the task was successful, false otherwise. /// </returns> protected override bool Execute(IIntegrationResult result) { // Initialise the task var logger = Logger ?? new DefaultLogger(); var numberOfTasks = Tasks.Length; result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : string.Format(System.Globalization.CultureInfo.CurrentCulture, "Running tasks in synchronisation context({0} task(s))", numberOfTasks)); logger.Info("Starting synchronisation task with {0} sub-task(s)", numberOfTasks); var contextToUse = this.ContextName ?? "DefaultSynchronisationContext"; // Make sure the context has been loaded lock (lockObject) { if (!contexts.ContainsKey(contextToUse)) { contexts.Add(contextToUse, new object()); } } // Attempt to enter the synchronisation context if (Monitor.TryEnter(contexts[contextToUse], TimeoutPeriod * 1000)) { try { // Launch each task var successCount = 0; var failureCount = 0; for (var loop = 0; loop < numberOfTasks; loop++) { var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} [{1}]", Tasks[loop].GetType().Name, loop); logger.Debug("Starting task '{0}'", taskName); try { // Start the actual task var taskResult = result.Clone(); var task = Tasks[loop]; RunTask(task, taskResult); result.Merge(taskResult); } catch (Exception error) { // Handle any error details result.ExceptionResult = error; result.Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results if (result.Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; if (!ContinueOnFailure) { break; } } } logger.Info("Parallel task completed: {0} successful, {1} failed", successCount, failureCount); } finally { Monitor.Exit(contexts[contextToUse]); } } else { // Set the result as failed logger.Warning("Unable to enter synchonisation context!"); result.Status = IntegrationStatus.Failure; } // Clean up this.CancelTasks(); return(result.Status == IntegrationStatus.Success); }
protected override bool Execute(IIntegrationResult result) { int loop = 0; foreach (var task in Tasks) { var taskResult = result.Clone(); RunTask(task, taskResult, new RunningSubTaskDetails(loop, result)); result.Merge(taskResult); loop++; } return true; }
/// <summary> /// Runs the task, given the specified <see cref="IIntegrationResult"/>, in the specified <see cref="IProject"/>. /// </summary> /// <param name="result">The results of the current build.</param> /// <returns><c>true</c> if the execution is successful; <c>false</c> otherwise.</returns> protected override bool Execute(IIntegrationResult result) { // Initialise the publisher var logger = this.Logger ?? new DefaultLogger(); result.BuildProgressInformation.SignalStartRunTask(!string.IsNullOrEmpty(Description) ? Description : "Checking conditional publishers"); logger.Info("Checking conditional publishers"); // Check the conditions var runPublishers = false; foreach (var condition in this.Conditions ?? new IntegrationStatus[0]) { runPublishers |= condition == result.Status; } if (runPublishers) { // Run each publisher logger.Info("Conditions met - running publishers"); for (var loop = 0; loop < this.Tasks.Length; loop++) { logger.Debug("Running publisher #{0}", loop); try { var taskResult = result.Clone(); var publisher = this.Tasks[loop]; RunTask(publisher, taskResult, new RunningSubTaskDetails(loop, result)); result.Merge(taskResult); } catch (Exception e) { logger.Error("Publisher threw exception: {0}", e.Message); } } } else { logger.Info("Conditions not met - publishers not run"); } // Clean up this.CancelTasks(); return true; }
/// <summary> /// Runs the task, given the specified <see cref="IIntegrationResult"/>, in the specified <see cref="IProject"/>. /// </summary> /// <param name="result"></param> protected override bool Execute(IIntegrationResult result) { // Initialise the task var logger = Logger ?? new DefaultLogger(); var numberOfTasks = Tasks.Length; tasksDetails = new ParallelRunningSubTaskDetails[numberOfTasks]; result.BuildProgressInformation.SignalStartRunTask(GetStatusInformation(null)); logger.Info("Starting parallel task with {0} sub-task(s)", numberOfTasks); // Initialise the arrays var events = new ManualResetEvent[numberOfTasks]; var results = new IIntegrationResult[numberOfTasks]; for (var loop = 0; loop < numberOfTasks; loop++) { events[loop] = new ManualResetEvent(false); results[loop] = result.Clone(); tasksDetails[loop] = new ParallelRunningSubTaskDetails(loop, result); } // Launch each task using the ThreadPool var countLock = new object(); var successCount = 0; var failureCount = 0; for (var loop = 0; loop < numberOfTasks; loop++) { ThreadPool.QueueUserWorkItem((state) => { var taskNumber = (int)state; var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture,"{0} [{1}]", Tasks[taskNumber].GetType().Name, taskNumber); try { Thread.CurrentThread.Name = string.Format(System.Globalization.CultureInfo.CurrentCulture,"{0} [Parallel-{1}]", result.ProjectName, taskNumber); logger.Debug("Starting task '{0}'", taskName); // Start the actual task var task = Tasks[taskNumber]; var taskResult = results[taskNumber]; RunTask(task, taskResult, tasksDetails[taskNumber]); } catch (Exception error) { // Handle any error details results[taskNumber].ExceptionResult = error; results[taskNumber].Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results lock (countLock) { if (results[taskNumber].Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; } } tasksDetails[taskNumber].Finished = true; tasksDetails[taskNumber].ParentResult.BuildProgressInformation.UpdateStartupInformation(GetStatusInformation(tasksDetails[taskNumber])); // Tell everyone the task is done events[taskNumber].Set(); }, loop); } // Wait for all the tasks to complete logger.Debug("Waiting for tasks to complete"); WaitHandle.WaitAll(events); // Merge all the results logger.Info("Merging task results"); foreach (var taskResult in results) { result.Merge(taskResult); } // Clean up this.CancelTasks(); logger.Info("Parallel task completed: {0} successful, {1} failed", successCount, failureCount); return true; }
private void AddResultMockExpectedClone(IIntegrationResult result) { Expect.Call(result.Clone()). Do((Func<IIntegrationResult>)(() => { var clone = mocks.StrictMock<IIntegrationResult>(); SetupResult.For(clone.BuildProgressInformation).Return(result.BuildProgressInformation); SetupResult.For(clone.Status).PropertyBehavior(); SetupResult.For(clone.ExceptionResult).PropertyBehavior(); clone.Status = result.Status; clone.Replay(); return clone; })); }
/// <summary> /// Runs the task, given the specified <see cref="IIntegrationResult"/>, in the specified <see cref="IProject"/>. /// </summary> /// <param name="result"></param> protected override bool Execute(IIntegrationResult result) { // Initialise the task var logger = Logger ?? new DefaultLogger(); var numberOfTasks = Tasks.Length; tasksDetails = new ParallelRunningSubTaskDetails[numberOfTasks]; result.BuildProgressInformation.SignalStartRunTask(GetStatusInformation(null)); logger.Info("Starting parallel task with {0} sub-task(s)", numberOfTasks); // Initialise the arrays var events = new ManualResetEvent[numberOfTasks]; var results = new IIntegrationResult[numberOfTasks]; for (var loop = 0; loop < numberOfTasks; loop++) { events[loop] = new ManualResetEvent(false); results[loop] = result.Clone(); tasksDetails[loop] = new ParallelRunningSubTaskDetails(loop, result); } // Launch each task using the ThreadPool var countLock = new object(); var successCount = 0; var failureCount = 0; for (var loop = 0; loop < numberOfTasks; loop++) { ThreadPool.QueueUserWorkItem((state) => { var taskNumber = (int)state; var taskName = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} [{1}]", Tasks[taskNumber].GetType().Name, taskNumber); try { Thread.CurrentThread.Name = string.Format(System.Globalization.CultureInfo.CurrentCulture, "{0} [Parallel-{1}]", result.ProjectName, taskNumber); logger.Debug("Starting task '{0}'", taskName); // Start the actual task var task = Tasks[taskNumber]; var taskResult = results[taskNumber]; RunTask(task, taskResult, tasksDetails[taskNumber]); } catch (Exception error) { // Handle any error details results[taskNumber].ExceptionResult = error; results[taskNumber].Status = IntegrationStatus.Failure; logger.Warning("Task '{0}' failed!", taskName); } // Record the results lock (countLock) { if (results[taskNumber].Status == IntegrationStatus.Success) { successCount++; } else { failureCount++; } } tasksDetails[taskNumber].Finished = true; tasksDetails[taskNumber].ParentResult.BuildProgressInformation.UpdateStartupInformation(GetStatusInformation(tasksDetails[taskNumber])); // Tell everyone the task is done events[taskNumber].Set(); }, loop); } // Wait for all the tasks to complete logger.Debug("Waiting for tasks to complete"); WaitHandle.WaitAll(events); // Merge all the results logger.Info("Merging task results"); foreach (var taskResult in results) { result.Merge(taskResult); } // Clean up this.CancelTasks(); logger.Info("Parallel task completed: {0} successful, {1} failed", successCount, failureCount); return(true); }
protected override bool Execute(IIntegrationResult result) { result.BuildProgressInformation.SignalStartRunTask("Executing TqForeachFromDB"); var loopTarget = GetData(); int numberOfTasks = Tasks?.Length ?? 0; int successCount = 0; int failureCount = 0; result.BuildProgressInformation.SignalStartRunTask($"Running tasks {numberOfTasks} rows {loopTarget}"); ITask task = null; ApplyDbDataUtil applyDbDataUtil; foreach (var data in loopTarget) { for (int i = 0; i < numberOfTasks; i++) { applyDbDataUtil = new ApplyDbDataUtil(); try { var taskResult = result.Clone(); taskResult.Status = IntegrationStatus.Unknown; task = Tasks[i]; applyDbDataUtil.ApplyDbData(task, data); RunTask(task, taskResult, new RunningSubTaskDetails(i, result)); result.Merge(taskResult); } catch (Exception ex) { result.ExceptionResult = ex; result.Status = IntegrationStatus.Failure; } finally { if (task != null) { applyDbDataUtil.RestoreDbData(task, data); } } if (result.Status != IntegrationStatus.Success) { failureCount++; break; } } successCount++; } // Clean up if (numberOfTasks > 0) { CancelTasks(); } return(failureCount == 0); }