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);
}
public TsdbEngine(IWorkProvider <TKey> workProvider, TsdbClient <TKey, TEntry> client, ITsdbLogger logger)
{
_client = client;
_workProvider = workProvider;
_logger = logger;
_scheduler = new EventScheduler();
_scheduledWork = new Dictionary <TKey, TsdbScheduledMoval <TKey, TEntry> >();
}
private static void DoWork(IWorkProvider workProvider, int workThreadCount)
{
IWorkDoer workDoer = new WorkDoer(workThreadCount);
workDoer.DoWork(workProvider);
workDoer.WaitToEnd();
}
private void DoWorkOnThread(IWorkProvider workProvider)
{
try
{
Action work = workProvider.GetWork();
work();
}
catch (Exception ex)
{
Interlocked.CompareExchange(ref _Exception, ex, null);
Stop();
}
}
private async Task RenewAsync(IWorkProvider provider, WorkItem item, CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
try
{
await Task.Delay(TimeSpan.FromSeconds(_quidjiboConfiguration.LockInterval), cancellationToken);
await provider.RenewAsync(item, cancellationToken);
_logger.LogDebug("Renewed : {0}", item.Id);
}
catch (OperationCanceledException)
{
// ignore OperationCanceledExceptions
}
}
}
public void Init()
{
_loggerFactory = Substitute.For <ILoggerFactory>();
_scheduleProviderFactory = Substitute.For <IScheduleProviderFactory>();
_scheduleProvider = Substitute.For <IScheduleProvider>();
_workProviderFactory = Substitute.For <IWorkProviderFactory>();
_workProvider = Substitute.For <IWorkProvider>();
_payloadSerializer = Substitute.For <IPayloadSerializer>();
_payloadProtector = Substitute.For <IPayloadProtector>();
_cronProvider = Substitute.For <ICronProvider>();
_sut = new QuidjiboClient(
_loggerFactory,
_workProviderFactory,
_scheduleProviderFactory,
_payloadSerializer,
_payloadProtector,
_cronProvider);
_sut.Clear();
}
public void DoWork(IWorkProvider workProvider)
{
if (_WorkProvider != null)
{
throw new InvalidOperationException($"This {nameof(WorkDoer)} has already been initialized, create new instance instead.");
}
_WorkProvider = workProvider ?? throw new ArgumentNullException(nameof(workProvider));
_Threads = new Thread[ThreadCount];
string providerType = workProvider.GetType().ToString();
for (int i = 0; i < ThreadCount; i++)
{
Thread workThread = new Thread(() => DoWorkOnThread(_WorkProvider));
workThread.IsBackground = true;
workThread.Name = $"{providerType}#{i}";
workThread.Start();
_Threads[i] = workThread;
}
}
public Worker(IWorkProvider workProvider)
{
_workProvider = workProvider;
}
public TsdbEngine(IWorkProvider <TKey> workProvider, TsdbClient <TKey, TEntry> client)
: this(workProvider, client, NullTsdbLogger.Default)
{
}
private async Task InvokePipelineAsync(IWorkProvider provider, WorkItem item)
{
using (var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token))
{
var progress = new QuidjiboProgress();
progress.ProgressChanged += async(sender, tracker) =>
{
var progressProvider = await _progressProviderFactory.CreateAsync(item.Queue, _cts.Token);
var progressItem = new ProgressItem
{
Id = Guid.NewGuid(),
CorrelationId = item.CorrelationId,
RecordedOn = DateTime.UtcNow,
Name = item.Name,
Queue = item.Queue,
Note = tracker.Text,
Value = tracker.Value,
WorkId = item.Id
};
await progressProvider.ReportAsync(progressItem, _cts.Token);
};
var renewTask = RenewAsync(provider, item, linkedTokenSource.Token);
var context = new QuidjiboContext
{
Item = item,
WorkProvider = provider,
Progress = progress,
State = new PipelineState()
};
try
{
await _quidjiboPipeline.StartAsync(context, linkedTokenSource.Token);
if (context.State.Success)
{
await provider.CompleteAsync(item, linkedTokenSource.Token);
_logger.LogDebug("Completed : {0}", item.Id);
}
else
{
await provider.FaultAsync(item, linkedTokenSource.Token);
_logger.LogError("Faulted : {0}", item.Id);
}
}
catch (Exception exception)
{
_logger.LogError("Faulted : {0}, {1}", item.Id, exception);
await provider.FaultAsync(item, linkedTokenSource.Token);
}
finally
{
_logger.LogDebug("Release : {0}", item.Id);
linkedTokenSource.Cancel();
await renewTask;
await _quidjiboPipeline.EndAsync(context);
}
}
}
