Fix: PaymentRequests created via API never expires (#6657)

BTCPayServer/Services/DelayedTaskScheduler.cs

@@ -0,0 +1,84 @@
+#nullable enable
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using System.Threading;
+using Amazon.Runtime.Internal.Util;
+using Microsoft.Extensions.Logging;
+
+namespace BTCPayServer.Services
+{
+    public class DelayedTaskScheduler : IDisposable
+    {
+        public DelayedTaskScheduler(ILogger<DelayedTaskScheduler> logger)
+        {
+            Logger = logger;
+        }
+        record class TimerState(string Key, Func<Task> Act);
+        private readonly Dictionary<string, Timer> _timers = new();
+        bool disposed = false;
+
+        public ILogger<DelayedTaskScheduler> Logger { get; }
+
+        public void Schedule(string key, DateTimeOffset executeAt, Func<Task> act)
+        {
+            lock (_timers)
+            {
+                if (disposed)
+                    return;
+                _timers.TryGetValue(key, out var existing);
+                if (existing != null)
+                {
+                    existing.Dispose();
+                    _timers.Remove(key);
+                }
+                var due = executeAt - DateTimeOffset.UtcNow;
+                if (due < TimeSpan.Zero)
+                    due = TimeSpan.Zero;
+                var timer = new Timer(TimerCallback, new TimerState(key, act), Timeout.Infinite, Timeout.Infinite);
+                _timers.Add(key, timer);
+                timer.Change((long)due.TotalMilliseconds, (long)Timeout.Infinite);
+            }
+        }
+
+        void TimerCallback(object? state)
+        {
+            var s = (TimerState)state!;
+            Task.Run(async () =>
+            {
+                try
+                {
+                    await s.Act();
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError(ex, $"Error executing delayed task for key {s.Key}");
+                }
+                finally
+                {
+                    Timer? timer = null;
+                    lock (_timers)
+                    {
+                        if (_timers.TryGetValue(s.Key, out timer))
+                        {
+                            _timers.Remove(s.Key);
+                        }
+                    }
+                    timer?.Dispose();
+                }
+            });
+        }
+
+        public void Dispose()
+        {
+            lock (_timers)
+            {
+                disposed = true;
+                foreach (var t in _timers.Values)
+                    t.Dispose();
+                _timers.Clear();
+            }
+        }
+        }
+}