fix(Orleans.Runtime): Avoid activation collection ticket datetime overflow

Directory.Packages.props

@@ -45,6 +45,7 @@
     <PackageVersion Include="Microsoft.Extensions.ObjectPool" Version="8.0.11" />
     <PackageVersion Include="Microsoft.Extensions.Options" Version="8.0.2" />
     <PackageVersion Include="Microsoft.Extensions.Options.ConfigurationExtensions" Version="8.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.TimeProvider.Testing" Version="9.5.0" />
     <PackageVersion Include="Microsoft.Extensions.Http" Version="8.0.1" />
     <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.1" />
     <PackageVersion Include="Microsoft.Extensions.Hosting" Version="8.0.1" />
@@ -123,4 +124,4 @@
     <PackageVersion Include="Microsoft.SourceLink.GitHub" Version="8.0.0" />
     <PackageVersion Include="Microsoft.DotNet.GenAPI.Task" Version="9.0.103-servicing.25065.25" />
   </ItemGroup>
-</Project>
+</Project>

src/Orleans.Runtime/Catalog/ActivationCollector.cs

@@ -27,23 +27,21 @@ internal partial class ActivationCollector : IActivationWorkingSetObserver, ILif
         private Task _collectionLoopTask;
         private int collectionNumber;
         private int _activationCount;
-        private readonly IOptions<GrainCollectionOptions> _options;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ActivationCollector"/> class.
         /// </summary>
-        /// <param name="timerFactory">The timer factory.</param>
+        /// <param name="timeProvider">The time provider.</param>
         /// <param name="options">The options.</param>
         /// <param name="logger">The logger.</param>
         public ActivationCollector(
-            IAsyncTimerFactory timerFactory,
+            TimeProvider timeProvider,
             IOptions<GrainCollectionOptions> options,
             ILogger<ActivationCollector> logger)
         {
-            _options = options;
             quantum = options.Value.CollectionQuantum;
             shortestAgeLimit = new(options.Value.ClassSpecificCollectionAge.Values.Aggregate(options.Value.CollectionAge.Ticks, (a, v) => Math.Min(a, v.Ticks)));
-            nextTicket = MakeTicketFromDateTime(DateTime.UtcNow);
+            nextTicket = MakeTicketFromDateTime(timeProvider.GetUtcNow().UtcDateTime);
             this.logger = logger;
             _collectionTimer = new PeriodicTimer(quantum);
         }
@@ -325,11 +323,17 @@ private bool IsExpired(DateTime ticket)
             return ticket < nextTicket;
         }
 
-        private DateTime MakeTicketFromDateTime(DateTime timestamp)
+        public DateTime MakeTicketFromDateTime(DateTime timestamp)
         {
             // Round the timestamp to the next quantum. e.g. if the quantum is 1 minute and the timestamp is 3:45:22, then the ticket will be 3:46.
             // Note that TimeStamp.Ticks and DateTime.Ticks both return a long.
-            var ticket = new DateTime(((timestamp.Ticks - 1) / quantum.Ticks + 1) * quantum.Ticks, DateTimeKind.Utc);
+            var ticketTicks = ((timestamp.Ticks - 1) / quantum.Ticks + 1) * quantum.Ticks;
+            if (ticketTicks > DateTime.MaxValue.Ticks)
+            {
+                return DateTime.MaxValue;
+            }
+
+            var ticket = new DateTime(ticketTicks, DateTimeKind.Utc);
             if (ticket < nextTicket)
             {
                 throw new ArgumentException(string.Format("The earliest collection that can be scheduled from now is for {0}", new DateTime(nextTicket.Ticks - quantum.Ticks + 1, DateTimeKind.Utc)));

test/NonSilo.Tests/NonSilo.Tests.csproj

@@ -14,6 +14,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.TimeProvider.Testing" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="NSubstitute" />
     <PackageReference Include="NSubstitute.Analyzers.CSharp" />

test/NonSilo.Tests/Runtime/ActivationCollectorTests.cs

@@ -0,0 +1,60 @@
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using Microsoft.Extensions.Time.Testing;
+using Orleans.Configuration;
+using Xunit;
+
+namespace UnitTests.Runtime
+{
+    [TestCategory("BVT"), TestCategory("Runtime")]
+    public class ActivationCollectorTests
+    {
+        private readonly FakeTimeProvider timeProvider;
+        private readonly ActivationCollector collector;
+
+        public ActivationCollectorTests()
+        {
+            var grainCollectionOptions = Options.Create(new GrainCollectionOptions());
+            var logger = NullLogger<ActivationCollector>.Instance;
+
+            this.timeProvider = new FakeTimeProvider(DateTimeOffset.Parse("2025-01-01T00:00:00.000+00:00"));
+            this.collector = new ActivationCollector(timeProvider, grainCollectionOptions, logger);
+        }
+
+        [Theory, TestCategory("Activation")]
+        [InlineData("2025-01-01T00:00:00", "2025-01-01T00:00:00")]
+        [InlineData("2025-01-01T00:00:01", "2025-01-01T00:01:00")]
+        [InlineData("2025-01-01T00:00:59", "2025-01-01T00:01:00")]
+        [InlineData("2025-01-01T00:01:01", "2025-01-01T00:02:00")]
+        public void MakeTicketFromDateTime(string timestampString, string expectedTicketString)
+        {
+            var timestamp = DateTime.Parse(timestampString);
+            var expectedTicket = DateTime.Parse(expectedTicketString);
+
+            var actualTicket = collector.MakeTicketFromDateTime(timestamp);
+
+            Assert.Equal(expectedTicket, actualTicket);
+        }
+
+        [Fact, TestCategory("Activation")]
+        public void MakeTicketFromDateTime_MaxValue()
+        {
+            var expectedTicket = DateTime.MaxValue;
+
+            var actualTicket = collector.MakeTicketFromDateTime(DateTime.MaxValue);
+
+            Assert.Equal(expectedTicket, actualTicket);
+        }
+
+        [Fact, TestCategory("Activation")]
+        public void MakeTicketFromDateTime_Invalid_BeforeNextTicket()
+        {
+            var timestamp = this.timeProvider.GetUtcNow().AddMinutes(-5).UtcDateTime;
+
+            Assert.Throws<ArgumentException>(() =>
+            {
+                var ticket = collector.MakeTicketFromDateTime(timestamp);
+            });
+        }
+    }
+}