Validate IReminderTable during startup if any grains implement IRemindable

Author: ReubenBond

src/Orleans.Runtime/Hosting/DefaultSiloServices.cs

@@ -38,6 +38,7 @@
 
 using Orleans.Configuration.Validators;
 using Orleans.Runtime.Configuration;
+using System.Linq;
 
 namespace Orleans.Hosting
 {
@@ -92,7 +93,6 @@ internal static void AddDefaultServices(HostBuilderContext context, IServiceColl
 
             services.AddLogging();
             services.TryAddSingleton<ITimerRegistry, TimerRegistry>();
-            services.TryAddSingleton<IReminderRegistry, ReminderRegistry>();
             services.TryAddSingleton<GrainRuntime>();
             services.TryAddSingleton<IGrainRuntime, GrainRuntime>();
             services.TryAddSingleton<IGrainCancellationTokenRuntime, GrainCancellationTokenRuntime>();
@@ -143,6 +143,15 @@ internal static void AddDefaultServices(HostBuilderContext context, IServiceColl
             services.TryAddSingleton<Factory<Grain, IMultiClusterRegistrationStrategy, ILogConsistencyProtocolServices>>(FactoryUtility.Create<Grain, IMultiClusterRegistrationStrategy, ProtocolServices>);
             services.TryAddSingleton(FactoryUtility.Create<GrainDirectoryPartition>);
 
+            // Reminders
+            services.TryAddSingleton<IReminderRegistry, ReminderRegistry>();
+            if (services.LastOrDefault()?.ServiceType == typeof(IReminderRegistry))
+            {
+                // If the user has not overridden the reminder registry, also add a configuration validator
+                // to ensure that a reminder table is configured if any grains require reminders.
+                services.AddSingleton<IConfigurationValidator, ReminderTableConfigurationValidator>();
+            }
+
             // Placement
             services.AddSingleton<IConfigurationValidator, ActivationCountBasedPlacementOptionsValidator>();
             services.TryAddSingleton<PlacementDirectorsManager>();

src/Orleans.Runtime/ReminderService/ReminderTableConfigurationValidator.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using Microsoft.Extensions.DependencyInjection;
+
+namespace Orleans.Runtime.ReminderService
+{
+    internal class ReminderTableConfigurationValidator : IConfigurationValidator
+    {
+        internal const string ReminderServiceNotConfigured =
+              "The reminder service has not been configured. Reminders can be configured using extension methods from the following packages:"
+              + "\n  * Microsoft.Orleans.Reminders.AzureStorage via ISiloHostBuilder.UseAzureTableReminderService(...)"
+              + "\n  * Microsoft.Orleans.Reminders.AdoNet via ISiloHostBuilder.UseAdoNetReminderService(...)"
+              + "\n  * Microsoft.Orleans.Reminders.DynamoDB via via ISiloHostBuilder.UseDynamoDBReminderService(...)"
+              + "\n  * Microsoft.Orleans.OrleansRuntime via ISiloHostBuilder.UseInMemoryReminderService(...) (Note: for development purposes only)"
+              + "\n  * Others, see: https://www.nuget.org/packages?q=Microsoft.Orleans.Reminders.";
+        private readonly GrainTypeManager grainTypeManager;
+        private readonly IServiceProvider serviceProvider;
+
+        public ReminderTableConfigurationValidator(GrainTypeManager grainTypeManager, IServiceProvider serviceProvider)
+        {
+            this.grainTypeManager = grainTypeManager;
+            this.serviceProvider = serviceProvider;
+        }
+
+        public void ValidateConfiguration()
+        {
+            var reminderTable = this.serviceProvider.GetService<IReminderTable>();
+            if (reminderTable != null) return;
+
+            var allGrains = this.grainTypeManager.GrainClassTypeData.Select(data => data.Value);
+
+            var remindableGrains = new List<Type>();
+            foreach (var grain in allGrains)
+            {
+                if (typeof(IRemindable).IsAssignableFrom(grain.Type))
+                {
+                    remindableGrains.Add(grain.Type);
+                }
+            }
+
+            if (remindableGrains.Count > 0)
+            {
+                var message = new StringBuilder(ReminderServiceNotConfigured);
+                message.AppendLine("\nThe following grain classes require reminders:");
+
+                foreach (var grain in remindableGrains)
+                {
+                    message.AppendLine($"  * {grain.GetParseableName(TypeFormattingOptions.LogFormat)}");
+                }
+
+                throw new OrleansConfigurationException(message.ToString());
+            }
+        }
+    }
+}

test/NonSilo.Tests/Reminders/ReminderServiceConfigurationTests.cs

@@ -0,0 +1,46 @@
+using Orleans.ApplicationParts;
+using Orleans.Hosting;
+using Orleans.Metadata;
+using Orleans.Runtime;
+using System.Collections.Generic;
+using UnitTests.Grains;
+using Xunit;
+
+namespace NonSilo.Tests.Reminders
+{
+    [TestCategory("BVT")]
+    [TestCategory("Reminders")]
+    public class ReminderServiceConfigurationTests
+    {
+        /// <summary>
+        /// Tests that if an IRemindable grain is registered, then an IReminderTable must also be registered.
+        /// </summary>
+        [Fact]
+        public void ReminderService_ConfigurationValidatorTest()
+        {
+            var exception = Assert.Throws<OrleansConfigurationException>(() => new SiloHostBuilder()
+                .UseLocalhostClustering()
+                .ConfigureApplicationParts(parts => parts.AddFeatureProvider(new RemindableGrainFeatureProvider()))
+                .Build());
+
+            Assert.Contains(nameof(ReminderTestGrain2), exception.Message);
+
+            var builder = new SiloHostBuilder()
+                .UseLocalhostClustering()
+                .ConfigureApplicationParts(parts => parts.AddFeatureProvider(new RemindableGrainFeatureProvider()))
+                .UseInMemoryReminderService();
+            using (var silo = builder.Build())
+            {
+                Assert.NotNull(silo);
+            }
+        }
+
+        private class RemindableGrainFeatureProvider : IApplicationFeatureProvider<GrainClassFeature>
+        {
+            public void PopulateFeature(IEnumerable<IApplicationPart> parts, GrainClassFeature feature)
+            {
+                feature.Classes.Add(new GrainClassMetadata(typeof(ReminderTestGrain2)));
+            }
+        }
+    }
+}