public void Dispatch()
{
var stopwatch = new Stopwatch();
stopwatch.Start();
if (queue.AllCount > 0)
{
if (multiThreaded)
{
foreach (var job in jobs)
{
job.JobException += (sender, e) => JobException?.Invoke(sender, e);
job.EmptyQueue += balanceQueues;
job.Dispatch(queue);
}
WaitHandle.WaitAll(manualResetEvents);
}
else
{
foreach (var job in jobs)
{
job.Execute(queue);
}
}
}
stopwatch.Stop();
Completed?.Invoke(this, new CompletedArgs(stopwatch.Elapsed));
}
public void TestResultHasErrorWhenLoaderFails()
{
string errorMessage = "LoadingException";
string loaderID = "1111...55555";
object data = new object();
Exception exceptionToThrow = new Exception(errorMessage);
Mock <IExtractor <object> > extractorMock = new Mock <IExtractor <object> >();
Mock <ITransformer <object, object> > transformerMock = new Mock <ITransformer <object, object> >();
Mock <ILoader <object> > loaderMock = new Mock <ILoader <object> >();
extractorMock.Setup(_ => _.Extract()).Returns(data);
transformerMock.Setup(_ => _.Transform(data)).Returns(data);
loaderMock.Setup(_ => _.GetID()).Returns(loaderID);
loaderMock.Setup(_ => _.Load(data)).Throws(exceptionToThrow);
IProcessor processor =
new ProcessorBuilder <object>(loaderMock.Object)
.AddSource("ProcessWithLoadingError", extractorMock.Object, transformerMock.Object)
.Build();
IEnumerable <Task <JobResult> > tasks = processor.Process();
Task.WaitAll(new List <Task>(tasks).ToArray());
IEnumerator <Task <JobResult> > enumerator = tasks.GetEnumerator();
Assert.IsTrue(enumerator.MoveNext());
Task <JobResult> result = enumerator.Current;
Assert.IsNotNull(result);
Assert.IsTrue(result.IsCompletedSuccessfully);
Assert.IsNotNull(result.Result);
JobResult jobResult = result.Result;
Assert.IsFalse(jobResult.CompletedWithouErrors);
Assert.IsNotNull(jobResult.Errors);
IEnumerator <JobException> errorsEnumerator = jobResult.Errors.GetEnumerator();
Assert.IsTrue(errorsEnumerator.MoveNext());
JobException jobException = errorsEnumerator.Current;
Assert.AreEqual(Phase.LOADING, jobException.JobPhase);
Assert.AreEqual(loaderID, jobException.FaillingComponentID);
Assert.IsFalse(errorsEnumerator.MoveNext());
Assert.IsFalse(enumerator.MoveNext());
}
public JobException TryConvertException(Exception exp)
{
JobException res = null;
try
{
res = ConvertException(exp);
}
catch (Exception e)
{
}
return(res);
}
public void Execute(JobQueue queue)
{
while (queue.Dequeue(affinity).If(out var action))
{
try
{
action(affinity);
}
catch (Exception exception)
{
JobException?.Invoke(this, new JobExceptionArgs(affinity, exception));
}
}
}
public void TestResultHasErrorWhenExtractorFails()
{
object data = new object();
string errorMessage = "Expected exception.";
string extractorID = "extractor_175";
Exception exceptionToThrow = new Exception(errorMessage);
Mock <IExtractor <object> > extractorMock = new Mock <IExtractor <object> >();
Mock <ILoader <object> > loaderMock = new Mock <ILoader <object> >();
extractorMock.Setup(_ => _.Extract()).Throws(exceptionToThrow);
extractorMock.Setup(_ => _.GetID()).Returns(extractorID);
ProcessorBuilder <object> builder = new ProcessorBuilder <object>(loaderMock.Object);
IProcessor faillingProcessor =
builder.AddSource("FailingProcessor", extractorMock.Object).Build();
IEnumerable <Task <JobResult> > tasks = faillingProcessor.Process();
Task.WaitAll(new List <Task>(tasks).ToArray());
IEnumerator <Task <JobResult> > enumerator = tasks.GetEnumerator();
Assert.IsTrue(enumerator.MoveNext());
Task <JobResult> result = enumerator.Current;
Assert.IsTrue(result.IsCompletedSuccessfully);
JobResult jobResult = result.Result;
Assert.IsNotNull(jobResult);
Assert.IsFalse(jobResult.CompletedWithouErrors);
Assert.IsNotNull(jobResult.Errors);
IEnumerator <JobException> errorsEnumerator = jobResult.Errors.GetEnumerator();
Assert.IsTrue(errorsEnumerator.MoveNext());
JobException jobException = errorsEnumerator.Current;
Assert.AreEqual(Phase.EXTRACTION, jobException.JobPhase);
Assert.AreEqual(extractorID, jobException.FaillingComponentID);
Assert.IsFalse(errorsEnumerator.MoveNext());
Assert.IsFalse(enumerator.MoveNext());
}
public void Dispatch(JobQueue queue)
{
manualResetEvent.Reset();
var thread = new Thread(() =>
{
try
{
var coreMask = getCoreMask(affinity);
setProcessorAffinity(coreMask);
while (true)
{
while (queue.Dequeue(affinity).If(out var action))
{
try
{
action(affinity);
}
catch (Exception exception)
{
JobException?.Invoke(this, new JobExceptionArgs(affinity, exception));
}
Thread.Sleep(500);
}
lock (locker)
{
var args = new JobEmptyQueueArgs(affinity);
EmptyQueue?.Invoke(this, args);
if (args.Quit)
{
break;
}
}
}
}
finally
{
manualResetEvent.Set();
}
});
thread.Start();
}
public Task OnFailure(JobException exception)
{
return(Task.CompletedTask);
}
public Task OnFailure(JobException exception)
{
Log.Warning(exception, "Couldn't check for update");
return(Task.CompletedTask);
}
public Task OnFailure(JobException exception)
{
return(Task.FromResult <IRetryAction>(new AlwaysRetry()));
}
