< Summary

Information
Class: Elsa.Workflows.Runtime.BookmarkQueueWorker
Assembly: Elsa.Workflows.Runtime
File(s): /home/runner/work/elsa-core/elsa-core/src/modules/Elsa.Workflows.Runtime/Services/BookmarkQueueWorker.cs
Line coverage
87%
Covered lines: 29
Uncovered lines: 4
Coverable lines: 33
Total lines: 74
Line coverage: 87.8%
Branch coverage
83%
Covered branches: 5
Total branches: 6
Branch coverage: 83.3%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%11100%
Start()50%2283.33%
Stop()100%22100%
AwaitSignalAsync()100%2270%
ProcessAsync()100%11100%

File(s)

/home/runner/work/elsa-core/elsa-core/src/modules/Elsa.Workflows.Runtime/Services/BookmarkQueueWorker.cs

#LineLine coverage
 1using Microsoft.Extensions.DependencyInjection;
 2using Microsoft.Extensions.Logging;
 3using ThrottleDebounce;
 4
 5namespace Elsa.Workflows.Runtime;
 6
 7public class BookmarkQueueWorker : IBookmarkQueueWorker
 8{
 9    private readonly RateLimitedFunc<CancellationToken, Task> _rateLimitedProcessAsync;
 10    private CancellationTokenSource _cts = null!;
 11    private bool _running;
 12    private readonly IBookmarkQueueSignaler _signaler;
 13    private readonly IServiceScopeFactory _scopeFactory;
 14    private readonly ILogger<BookmarkQueueWorker> _logger;
 15
 1116    public BookmarkQueueWorker(IBookmarkQueueSignaler signaler, IServiceScopeFactory scopeFactory, ILogger<BookmarkQueue
 17    {
 1118        _signaler = signaler;
 1119        _scopeFactory = scopeFactory;
 1120        _logger = logger;
 1121        _rateLimitedProcessAsync = Throttler.Throttle<CancellationToken, Task>(ProcessAsync, TimeSpan.FromMilliseconds(5
 1122    }
 23
 24    public void Start()
 25    {
 1126        if (_running)
 027            return;
 28
 1129        _cts = new();
 1130        _running = true;
 31
 1132        _ = Task.Run(AwaitSignalAsync);
 1133    }
 34
 35    public void Stop()
 36    {
 737        if (_running)
 38        {
 739            _running = false;
 740            _cts.Cancel();
 41        }
 42
 743        _cts.Dispose();
 744    }
 45
 46    private async Task AwaitSignalAsync()
 47    {
 59948        while (!_cts.IsCancellationRequested)
 49        {
 50            try
 51            {
 59852                await _signaler.AwaitAsync(_cts.Token);
 58853                await _rateLimitedProcessAsync.InvokeAsync(_cts.Token);
 58854            }
 655            catch (OperationCanceledException)
 56            {
 657                break; // Stop() was called
 58            }
 059            catch (Exception ex)
 60            {
 061                _logger.LogError(ex, "BookmarkQueueWorker error – continuing loop");
 062            }
 63        }
 764    }
 65
 66    protected virtual async Task ProcessAsync(CancellationToken cancellationToken)
 67    {
 6268        _logger.LogDebug("Processing bookmark queue...");
 6269        using var scope = _scopeFactory.CreateScope();
 6270        var processor = scope.ServiceProvider.GetRequiredService<IBookmarkQueueProcessor>();
 6271        await processor.ProcessAsync(cancellationToken);
 6272        _logger.LogDebug("Processed bookmark queue.");
 6273    }
 74}