/// <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);
}
private static void RunTaskAndMergeResult(ITask task, IIntegrationResult result)
{
IIntegrationResult subResult = result.Clone();
try
{
task.Run(subResult);
}
finally
{
result.Merge(subResult);
}
}
/// <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);
}