Use a single thread loop to delete expired items (#4)

* Use a single thread loop to delete expired items

* Rollback minimum cache loop to 5 minutes

* Clean up code

* Not exposing class

* Using cancellation tokens

* Split responsibilities into each class

Clean up code

Author: dariogriffo

Extensions.Caching.PostgreSql/Columns.cs

@@ -5,26 +5,24 @@ namespace Community.Microsoft.Extensions.Caching.PostgreSql
 {
     internal static class Columns
     {
-        public static class Names
+        internal static class Names
         {
-            public const string CacheItemId = "DistCacheId";
-            public const string CacheItemValue = "DistCacheValue";
-            public const string ExpiresAtTime = "DistCacheExpiresAtTime";
-            public const string SlidingExpirationInSeconds = "DistCacheSlidingExpirationInSeconds";
-            public const string AbsoluteExpiration = "DistCacheAbsoluteExpiration";
+            internal const string CacheItemId = "DistCacheId";
+            internal const string CacheItemValue = "DistCacheValue";
+            internal const string ExpiresAtTime = "DistCacheExpiresAtTime";
+            internal const string SlidingExpirationInSeconds = "DistCacheSlidingExpirationInSeconds";
+            internal const string AbsoluteExpiration = "DistCacheAbsoluteExpiration";
         }
 
-        public static class Indexes
+        internal static class Indexes
         {
             // The value of the following index positions is dependent on how the SQL queries
             // are selecting the columns.
-            public const int CacheItemIdIndex = 0;
-            public const int CacheItemValueIndex = 1;
-            public const int ExpiresAtTimeIndex = 2;
-            public const int SlidingExpirationInSecondsIndex = 3;
-            public const int AbsoluteExpirationIndex = 4;
-            
-
+            internal const int CacheItemIdIndex = 0;
+            internal const int CacheItemValueIndex = 1;
+            internal const int ExpiresAtTimeIndex = 2;
+            internal const int SlidingExpirationInSecondsIndex = 3;
+            internal const int AbsoluteExpirationIndex = 4;
         }
     }
 }

Extensions.Caching.PostgreSql/Community.Microsoft.Extensions.Caching.PostgreSql.csproj

@@ -28,6 +28,7 @@
   </ItemGroup>-->
   <ItemGroup>
     <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="5.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="5.0.0" />
     <PackageReference Include="Microsoft.Extensions.Options" Version="5.0.0" />
     <PackageReference Include="Npgsql" Version="5.0.0" />
   </ItemGroup>

Extensions.Caching.PostgreSql/DatabaseExpiredItemsRemoverLoop.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Internal;
+using Microsoft.Extensions.Options;
+
+namespace Community.Microsoft.Extensions.Caching.PostgreSql
+{
+    internal sealed class DatabaseExpiredItemsRemoverLoop : IDatabaseExpiredItemsRemoverLoop
+    {
+        private static readonly TimeSpan MinimumExpiredItemsDeletionInterval = TimeSpan.FromMinutes(5);
+        private static readonly TimeSpan DefaultExpiredItemsDeletionInterval = TimeSpan.FromMinutes(30);
+        private readonly TimeSpan _expiredItemsDeletionInterval;
+        private DateTimeOffset _lastExpirationScan;
+        private readonly IDatabaseOperations _databaseOperations;
+        private readonly CancellationTokenSource _cancellationTokenSource;
+        private readonly ISystemClock _systemClock;
+
+        public DatabaseExpiredItemsRemoverLoop(
+            IOptions<PostgreSqlCacheOptions> options,
+            IDatabaseOperations databaseOperations,
+            IHostApplicationLifetime applicationLifetime)
+        {
+            var cacheOptions = options.Value;
+
+            if (cacheOptions.ExpiredItemsDeletionInterval.HasValue &&
+                cacheOptions.ExpiredItemsDeletionInterval.Value < MinimumExpiredItemsDeletionInterval)
+            {
+                throw new ArgumentException(
+                    $"{nameof(PostgreSqlCacheOptions.ExpiredItemsDeletionInterval)} cannot be less the minimum " +
+                    $"value of {MinimumExpiredItemsDeletionInterval.TotalMinutes} minutes.");
+            }
+
+            _systemClock = cacheOptions.SystemClock;
+            _cancellationTokenSource = new CancellationTokenSource();
+            applicationLifetime.ApplicationStopping.Register(OnShutdown);
+            _databaseOperations = databaseOperations;
+            _expiredItemsDeletionInterval = cacheOptions.ExpiredItemsDeletionInterval ?? DefaultExpiredItemsDeletionInterval;
+        }
+
+        public void Start()
+        {
+            Task.Run(DeleteExpiredCacheItems);
+        }
+
+        private void OnShutdown()
+        {
+            _cancellationTokenSource.Cancel();
+        }
+
+        private async Task DeleteExpiredCacheItems()
+        {
+            while (true)
+            {
+                var utcNow = _systemClock.UtcNow;
+                if ((utcNow - _lastExpirationScan) > _expiredItemsDeletionInterval)
+                {
+                    try
+                    {
+                        await _databaseOperations.DeleteExpiredCacheItemsAsync(_cancellationTokenSource.Token);
+                        _lastExpirationScan = utcNow;
+                    }
+                    catch (TaskCanceledException)
+                    {
+                        break;
+                    }
+                    catch (Exception)
+                    {
+                        //We don't want transient errors from failing next run
+                    }
+                }
+
+                try
+                {
+                    await Task
+                            .Delay(_expiredItemsDeletionInterval, _cancellationTokenSource.Token)
+                            .ConfigureAwait(true);
+                }
+                catch (TaskCanceledException)
+                {
+                    // ignore: Task.Delay throws this exception when ct.IsCancellationRequested = true
+                    // In this case, we only want to stop polling and finish this async Task.
+                    break;
+                }
+            }
+        }
+    }
+}