Sync changes from main to net8 - Applied recent commits, updated versions & framework, preserved .csproj files (#342)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

Author: arcenox

src/TickerQ.EntityFrameworkCore/Infrastructure/BasePersistenceProvider.cs

@@ -136,25 +136,38 @@ public async Task<TimeTickerEntity[]> GetEarliestTimeTickers(CancellationToken c
     {
         await using var dbContext = await DbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
         var now = _clock.UtcNow;
-        var mainSchedulerThreshold = now.AddMilliseconds(-now.Millisecond);
-
+    
+        // Define the window: ignore anything older than 1 second ago
+        var oneSecondAgo = now.AddSeconds(-1);
+    
         var baseQuery = dbContext.Set<TTimeTicker>()
             .AsNoTracking()
             .Where(x => x.ExecutionTime != null)
+            .Where(x => x.ExecutionTime >= oneSecondAgo)  // Ignore old tickers (fallback handles them)
             .WhereCanAcquire(_lockHolder);
-        
+    
+        // Find the earliest ticker within our window
         var minExecutionTime = await baseQuery
-            .Where(x => x.ExecutionTime >= mainSchedulerThreshold)
             .OrderBy(x => x.ExecutionTime)
             .Select(x => x.ExecutionTime)
             .FirstOrDefaultAsync(cancellationToken).ConfigureAwait(false);
 
         if (minExecutionTime == null)
             return [];
-        
+    
+        // Round the minimum execution time down to its second
+        var minSecond = new DateTime(minExecutionTime.Value.Year, minExecutionTime.Value.Month,
+            minExecutionTime.Value.Day, minExecutionTime.Value.Hour,
+            minExecutionTime.Value.Minute, minExecutionTime.Value.Second,
+            DateTimeKind.Utc);
+    
+        // Fetch all tickers within that complete second (this ensures we get all tickers in the same second)
+        var maxExecutionTime = minSecond.AddSeconds(1);
+    
         return await baseQuery
             .Include(x => x.Children.Where(y => y.ExecutionTime == null))
-            .Where(x => x.ExecutionTime.Value >= minExecutionTime && x.ExecutionTime <= now.AddSeconds(1).AddMilliseconds(-now.Millisecond))
+            .Where(x => x.ExecutionTime >= minSecond && x.ExecutionTime < maxExecutionTime)
+            .OrderBy(x => x.ExecutionTime)
             .Select(MappingExtensions.ForQueueTimeTickers<TTimeTicker>())
             .ToArrayAsync(cancellationToken).ConfigureAwait(false);
     }

src/TickerQ.Utilities/Managers/InternalTickerManager.cs

@@ -82,36 +82,47 @@ private TimeSpan CalculateMinTimeRemaining(
             if (time is null)
             {
                 sources = [TickerType.CronTickerOccurrence];
-                return cron.Value - now;
+                var cronRemaining = cron.Value - now;
+                // Ensure we don't return negative values - schedule for immediate execution
+                return cronRemaining < TimeSpan.Zero ? TimeSpan.Zero : cronRemaining;
             }
 
             // only time
             if (cron is null)
             {
                 sources = [TickerType.TimeTicker];
-                return time.Value - now;
+                var timeRemaining = time.Value - now;
+                // Ensure we don't return negative values - schedule for immediate execution
+                return timeRemaining < TimeSpan.Zero ? TimeSpan.Zero : timeRemaining;
             }
 
-            // both present - check if they're close enough to batch together
-            var timeDiff = Math.Abs((cron.Value - time.Value).TotalMilliseconds);
+            // both present - check if they're in the exact same second (ignoring milliseconds)
+            var cronSecond = new DateTime(cron.Value.Year, cron.Value.Month, cron.Value.Day, 
+                                          cron.Value.Hour, cron.Value.Minute, cron.Value.Second);
+            var timeSecond = new DateTime(time.Value.Year, time.Value.Month, time.Value.Day,
+                                          time.Value.Hour, time.Value.Minute, time.Value.Second);
 
-            // Only batch if within 50ms of each other for efficiency
-            if (timeDiff <= 250)
+            // Only batch if they're in the exact same second
+            if (cronSecond == timeSecond)
             {
                 sources = [TickerType.CronTickerOccurrence, TickerType.TimeTicker];
                 var earliest = cron < time ? cron.Value : time.Value;
-                return earliest - now;
+                var earliestRemaining = earliest - now;
+                // Ensure we don't return negative values
+                return earliestRemaining < TimeSpan.Zero ? TimeSpan.Zero : earliestRemaining;
             }
 
-            // Different times - only process the earliest one
+            // Different seconds - only process the earliest one
             if (cron < time)
             {
                 sources = [TickerType.CronTickerOccurrence];
-                return cron.Value - now;
+                var cronRemaining = cron.Value - now;
+                return cronRemaining < TimeSpan.Zero ? TimeSpan.Zero : cronRemaining;
             }
 
             sources = [TickerType.TimeTicker];
-            return time.Value - now;
+            var finalTimeRemaining = time.Value - now;
+            return finalTimeRemaining < TimeSpan.Zero ? TimeSpan.Zero : finalTimeRemaining;
         }
 
         private async Task<InternalFunctionContext[]>RetrieveEligibleTickersAsync(

src/TickerQ/Src/BackgroundServices/TickerQSchedulerBackgroundService.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Hosting;
@@ -104,7 +105,7 @@ private async Task RunTickerQSchedulerAsync(CancellationToken stoppingToken, Can
             {
                 await _internalTickerManager.SetTickersInProgress(_executionContext.Functions, cancellationToken);
 
-                foreach (var function in _executionContext.Functions)
+                foreach (var function in _executionContext.Functions.OrderBy(x => x.CachedPriority))
                     await _taskScheduler.QueueAsync(async ct => await _taskHandler.ExecuteTaskAsync(function,false, ct), function.CachedPriority, stoppingToken);
             }
 

src/TickerQ/Src/TickerQThreadPool/PriorityTask.cs

@@ -38,7 +38,7 @@ public override void Post(SendOrPostCallback d, object state)
         else
         {
             // We're not on a TickerQ worker - safe to queue the continuation
-            _scheduler.QueueContinuation(() => d(state));
+            _scheduler.PostContinuation(d, state);
         }
     }