| | | 1 | | using Elsa.Common; |
| | | 2 | | using Elsa.Mediator.Contracts; |
| | | 3 | | using Elsa.Scheduling.Commands; |
| | | 4 | | using Microsoft.Extensions.DependencyInjection; |
| | | 5 | | using Microsoft.Extensions.Logging; |
| | | 6 | | using Timer = System.Timers.Timer; |
| | | 7 | | |
| | | 8 | | namespace Elsa.Scheduling.ScheduledTasks; |
| | | 9 | | |
| | | 10 | | /// <summary> |
| | | 11 | | /// A task that is scheduled to execute at a specific instant. |
| | | 12 | | /// </summary> |
| | | 13 | | public class ScheduledSpecificInstantTask : IScheduledTask, IDisposable |
| | | 14 | | { |
| | | 15 | | private readonly ITask _task; |
| | | 16 | | private readonly ISystemClock _systemClock; |
| | | 17 | | private readonly IServiceScopeFactory _scopeFactory; |
| | | 18 | | private readonly ILogger<ScheduledSpecificInstantTask> _logger; |
| | | 19 | | private readonly DateTimeOffset _startAt; |
| | | 20 | | private readonly CancellationTokenSource _cancellationTokenSource; |
| | 17 | 21 | | private readonly SemaphoreSlim _executionSemaphore = new(1, 1); |
| | | 22 | | private Timer? _timer; |
| | | 23 | | private bool _executing; |
| | | 24 | | private bool _cancellationRequested; |
| | | 25 | | private bool _disposed; |
| | | 26 | | |
| | | 27 | | /// <summary> |
| | | 28 | | /// Initializes a new instance of <see cref="ScheduledSpecificInstantTask"/>. |
| | | 29 | | /// </summary> |
| | 17 | 30 | | public ScheduledSpecificInstantTask(ITask task, DateTimeOffset startAt, ISystemClock systemClock, IServiceScopeFacto |
| | | 31 | | { |
| | 17 | 32 | | _task = task; |
| | 17 | 33 | | _systemClock = systemClock; |
| | 17 | 34 | | _scopeFactory = scopeFactory; |
| | 17 | 35 | | _logger = logger; |
| | 17 | 36 | | _startAt = startAt; |
| | 17 | 37 | | _cancellationTokenSource = new(); |
| | | 38 | | |
| | 17 | 39 | | Schedule(); |
| | 17 | 40 | | } |
| | | 41 | | |
| | | 42 | | /// <inheritdoc /> |
| | | 43 | | public void Cancel() |
| | | 44 | | { |
| | 13 | 45 | | _timer?.Dispose(); |
| | | 46 | | |
| | 13 | 47 | | if (_executing) |
| | | 48 | | { |
| | 6 | 49 | | _cancellationRequested = true; |
| | 6 | 50 | | return; |
| | | 51 | | } |
| | | 52 | | |
| | 7 | 53 | | _cancellationTokenSource.Cancel(); |
| | 7 | 54 | | } |
| | | 55 | | |
| | | 56 | | private void Schedule() |
| | | 57 | | { |
| | 17 | 58 | | var now = _systemClock.UtcNow; |
| | 17 | 59 | | var delay = _startAt - now; |
| | | 60 | | |
| | | 61 | | // Handle edge cases where delay is zero or negative (e.g., due to clock drift, fast execution, or time alignmen |
| | | 62 | | // Instead of silently returning, use a minimum delay to ensure the timer fires and workflow continues schedulin |
| | 17 | 63 | | if (delay <= TimeSpan.Zero) |
| | | 64 | | { |
| | 3 | 65 | | _logger.LogWarning("Calculated delay is {Delay} which is not positive. Using minimum delay of 1ms to ensure |
| | 3 | 66 | | delay = TimeSpan.FromMilliseconds(1); |
| | | 67 | | } |
| | | 68 | | |
| | 17 | 69 | | _timer = new(delay.TotalMilliseconds) |
| | 17 | 70 | | { |
| | 17 | 71 | | Enabled = true |
| | 17 | 72 | | }; |
| | | 73 | | |
| | 17 | 74 | | _timer.Elapsed += async (_, _) => |
| | 17 | 75 | | { |
| | 8 | 76 | | _timer?.Dispose(); |
| | 8 | 77 | | _timer = null; |
| | 17 | 78 | | |
| | 17 | 79 | | // Check if disposed before proceeding |
| | 9 | 80 | | if (_disposed) return; |
| | 17 | 81 | | |
| | 7 | 82 | | using var scope = _scopeFactory.CreateScope(); |
| | 7 | 83 | | var commandSender = scope.ServiceProvider.GetRequiredService<ICommandSender>(); |
| | 17 | 84 | | |
| | 17 | 85 | | // Check disposed again before accessing CancellationTokenSource |
| | 7 | 86 | | if (_disposed) return; |
| | 17 | 87 | | |
| | 7 | 88 | | var cancellationToken = _cancellationTokenSource.Token; |
| | 7 | 89 | | if (!cancellationToken.IsCancellationRequested) |
| | 17 | 90 | | { |
| | 7 | 91 | | var acquired = false; |
| | 17 | 92 | | try |
| | 17 | 93 | | { |
| | 7 | 94 | | acquired = await _executionSemaphore.WaitAsync(0, cancellationToken); |
| | 7 | 95 | | if (!acquired) return; |
| | 7 | 96 | | _executing = true; |
| | 7 | 97 | | await commandSender.SendAsync(new RunScheduledTask(_task), cancellationToken); |
| | 17 | 98 | | |
| | 7 | 99 | | if (_cancellationRequested) |
| | 17 | 100 | | { |
| | 6 | 101 | | _cancellationRequested = false; |
| | 6 | 102 | | _cancellationTokenSource.Cancel(); |
| | 17 | 103 | | } |
| | 7 | 104 | | } |
| | 0 | 105 | | catch (Exception e) |
| | 17 | 106 | | { |
| | 0 | 107 | | _logger.LogError(e, "Error executing scheduled task"); |
| | 0 | 108 | | } |
| | 17 | 109 | | finally |
| | 17 | 110 | | { |
| | 7 | 111 | | _executing = false; |
| | 7 | 112 | | if (acquired && !_disposed) |
| | 7 | 113 | | _executionSemaphore.Release(); |
| | 17 | 114 | | } |
| | 17 | 115 | | } |
| | 25 | 116 | | }; |
| | 17 | 117 | | } |
| | | 118 | | |
| | | 119 | | void IDisposable.Dispose() |
| | | 120 | | { |
| | 5 | 121 | | _disposed = true; |
| | 5 | 122 | | _timer?.Dispose(); |
| | 5 | 123 | | _cancellationTokenSource.Dispose(); |
| | 5 | 124 | | _executionSemaphore.Dispose(); |
| | 5 | 125 | | } |
| | | 126 | | } |