private async Task WorkLoopAsync(string queue)
{
var pollingInterval = TimeSpan.FromSeconds(_workProviderFactory.PollingInterval);
var workProvider = await _workProviderFactory.CreateAsync(queue, _cts.Token);
while (!_cts.IsCancellationRequested)
{
try
{
_logger.LogDebug("Throttle Count : {0}", _throttle.CurrentCount);
// throttle is important when there is more than one listener
await _throttle.WaitAsync(_cts.Token);
var items = await workProvider.ReceiveAsync(Worker, _cts.Token);
if (items.Any())
{
var tasks = items.Select(item => InvokePipelineAsync(workProvider, item));
await Task.WhenAll(tasks);
_throttle.Release();
continue;
}
_throttle.Release();
await Task.Delay(pollingInterval, _cts.Token);
}
catch (Exception exception)
{
_logger.LogWarning(0, exception, exception.Message);
}
}
}
public void Init()
{
_cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
_loggerFactory = Substitute.For <ILoggerFactory>();
_logger = Substitute.For <ILogger <QuidjiboServer> >();
_loggerFactory.CreateLogger <QuidjiboServer>().Returns(_logger);
_quidjiboConfiguration = Substitute.For <IQuidjiboConfiguration>();
_workProviderFactory = Substitute.For <IWorkProviderFactory>();
_workProvider = Substitute.For <IWorkProvider>();
_workProviderFactory.CreateAsync(Arg.Any <string>(), Arg.Any <CancellationToken>()).Returns(Task.FromResult(_workProvider));
_workProviderFactory.PollingInterval.Returns(1);
_scheduleProviderFactory = Substitute.For <IScheduleProviderFactory>();
_scheduleProvider = Substitute.For <IScheduleProvider>();
_scheduleProviderFactory.CreateAsync(Arg.Any <string[]>(), Arg.Any <CancellationToken>()).Returns(Task.FromResult(_scheduleProvider));
_scheduleProviderFactory.PollingInterval.Returns(1);
_progressProviderFactory = Substitute.For <IProgressProviderFactory>();
_progressProvider = Substitute.For <IProgressProvider>();
_progressProviderFactory.CreateAsync(Arg.Any <string[]>(), Arg.Any <CancellationToken>()).Returns(Task.FromResult(_progressProvider));
Substitute.For <IWorkDispatcher>();
Substitute.For <IPayloadSerializer>();
_cronProvider = Substitute.For <ICronProvider>();
_pipeline = Substitute.For <IQuidjiboPipeline>();
_sut = new QuidjiboServer(_loggerFactory, _quidjiboConfiguration, _workProviderFactory, _scheduleProviderFactory, _progressProviderFactory, _cronProvider, _pipeline);
}
private async Task WorkLoopAsync(string queue)
{
var pollingInterval = TimeSpan.FromSeconds(_quidjiboConfiguration.WorkPollingInterval ?? 45);
var workProvider = await _workProviderFactory.CreateAsync(queue, _cts.Token);
while (!_cts.IsCancellationRequested)
{
var items = new List <WorkItem>(0);
try
{
_logger.LogTrace("Throttle Count : {ThrottleCount}", _throttle.CurrentCount);
// throttle is important when there is more than one listener
await _throttle.WaitAsync(_cts.Token);
items = await workProvider.ReceiveAsync(Worker, _cts.Token);
if (items.Count > 0)
{
_logger.LogDebug("Received {WorkItemCount} items.", items.Count);
var tasks = items.Select(item => InvokePipelineAsync(workProvider, item));
await Task.WhenAll(tasks);
}
}
catch (Exception exception)
{
_logger.LogWarning(0, exception, exception.Message);
}
finally
{
_throttle.Release();
}
if (items == null || items.Count <= 0)
{
await Task.Delay(pollingInterval, _cts.Token);
}
}
}
private Task <IWorkProvider> GetOrCreateWorkProvider(string queueName, CancellationToken cancellationToken)
{
return(_workProviderFactory.CreateAsync(queueName, cancellationToken));
}