Add startup tasks to replace deprecated bootstrap providers

src/Orleans.Core/Runtime/Constants.cs

@@ -37,6 +37,7 @@ internal class Constants
         public static readonly GrainId MembershipOracleId = GrainId.GetSystemTargetGrainId(15);
         public static readonly GrainId TypeManagerId = GrainId.GetSystemTargetGrainId(17);
         public static readonly GrainId FallbackSystemTargetId = GrainId.GetSystemTargetGrainId(19);
+        public static readonly GrainId StartupTaskSystemTargetId = GrainId.GetSystemTargetGrainId(20);
         public static readonly GrainId DeploymentLoadPublisherSystemTargetId = GrainId.GetSystemTargetGrainId(22);
         public static readonly GrainId MultiClusterOracleId = GrainId.GetSystemTargetGrainId(23);
         public static readonly GrainId ClusterDirectoryServiceId = GrainId.GetSystemTargetGrainId(24);

src/Orleans.Runtime/Hosting/DefaultSiloServices.cs

@@ -260,6 +260,9 @@ internal static void AddDefaultServices(HostBuilderContext context, IServiceColl
             services.TryConfigureFormatter<EndpointOptions, EndpointOptionsFormatter>();
 
             services.AddTransient<IConfigurationValidator, EndpointOptionsValidator>();
+
+            services.AddSingleton<StartupTaskSystemTarget>();
+
         }
     }
 }

src/Orleans.Runtime/Lifecycle/IStartupTask.cs

@@ -0,0 +1,18 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Orleans.Runtime
+{
+    /// <summary>
+    /// Defines an action to be taken during silo startup.
+    /// </summary>
+    public interface IStartupTask
+    {
+        /// <summary>
+        /// Called after the silo has started.
+        /// </summary>
+        /// <param name="cancellationToken">The cancellation token which is canceled when the method must abort.</param>
+        /// <returns>A <see cref="Task"/> representing the work performed.</returns>
+        Task Execute(CancellationToken cancellationToken);
+    }
+}

src/Orleans.Runtime/Lifecycle/SiloBuilderStartupExtensions.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Microsoft.Extensions.DependencyInjection;
+
+using Orleans.Runtime;
+using Orleans.Runtime.Scheduler;
+
+namespace Orleans.Hosting
+{
+    /// <summary>
+    /// The silo builder startup extensions.
+    /// </summary>
+    public static class SiloBuilderStartupExtensions
+    {
+        /// <summary>
+        /// Adds a startup task to be executed when the silo has started.
+        /// </summary>
+        /// <param name="builder">
+        /// The builder.
+        /// </param>
+        /// <param name="stage">
+        /// The stage to execute the startup task, see values in <see cref="SiloLifecycleStage"/>.
+        /// </param>
+        /// <typeparam name="TStartup">
+        /// The startup task type.
+        /// </typeparam>
+        /// <returns>
+        /// The provided <see cref="ISiloHostBuilder"/>.
+        /// </returns>
+        public static ISiloHostBuilder AddStartupTask<TStartup>(
+            this ISiloHostBuilder builder,
+            int stage = SiloLifecycleStage.SiloActive)
+            where TStartup : class, IStartupTask
+        {
+            return builder.AddStartupTask((sp, ct) => ActivatorUtilities.GetServiceOrCreateInstance<TStartup>(sp).Execute(ct), stage);
+        }
+
+        /// <summary>
+        /// Adds a startup task to be executed when the silo has started.
+        /// </summary>
+        /// <param name="builder">
+        /// The builder.
+        /// </param>
+        /// <param name="startupTask">
+        /// The startup task.
+        /// </param>
+        /// <param name="stage">
+        /// The stage to execute the startup task, see values in <see cref="SiloLifecycleStage"/>.
+        /// </param>
+        /// <returns>
+        /// The provided <see cref="ISiloHostBuilder"/>.
+        /// </returns>
+        public static ISiloHostBuilder AddStartupTask(
+            this ISiloHostBuilder builder,
+            IStartupTask startupTask,
+            int stage = SiloLifecycleStage.SiloActive)
+        {
+            return builder.AddStartupTask((sp, ct) => startupTask.Execute(ct), stage);
+        }
+
+        /// <summary>
+        /// Adds a startup task to be executed when the silo has started.
+        /// </summary>
+        /// <param name="builder">
+        /// The builder.
+        /// </param>
+        /// <param name="startupTask">
+        /// The startup task.
+        /// </param>
+        /// <param name="stage">
+        /// The stage to execute the startup task, see values in <see cref="SiloLifecycleStage"/>.
+        /// </param>
+        /// <returns>
+        /// The provided <see cref="ISiloHostBuilder"/>.
+        /// </returns>
+        public static ISiloHostBuilder AddStartupTask(
+            this ISiloHostBuilder builder,
+            Func<IServiceProvider, CancellationToken, Task> startupTask,
+            int stage = SiloLifecycleStage.SiloActive)
+        {
+            builder.ConfigureServices(services =>
+                services.AddTransient<ILifecycleParticipant<ISiloLifecycle>>(sp =>
+                    new StartupTask(
+                        sp,
+                        sp.GetRequiredService<OrleansTaskScheduler>(),
+                        sp.GetRequiredService<StartupTaskSystemTarget>(),
+                        startupTask,
+                        stage)));
+            return builder;
+        }
+
+        /// <inheritdoc />
+        private class StartupTask : ILifecycleParticipant<ISiloLifecycle>
+        {
+            private readonly IServiceProvider serviceProvider;
+            private readonly OrleansTaskScheduler scheduler;
+            private readonly StartupTaskSystemTarget schedulingTarget;
+            private readonly Func<IServiceProvider, CancellationToken, Task> startupTask;
+
+            private readonly int stage;
+
+            public StartupTask(
+                IServiceProvider serviceProvider,
+                OrleansTaskScheduler scheduler,
+                StartupTaskSystemTarget schedulingTarget,
+                Func<IServiceProvider, CancellationToken, Task> startupTask,
+                int stage)
+            {
+                this.serviceProvider = serviceProvider;
+                this.scheduler = scheduler;
+                this.schedulingTarget = schedulingTarget;
+                this.startupTask = startupTask;
+                this.stage = stage;
+            }
+
+            /// <inheritdoc />
+            public void Participate(ISiloLifecycle lifecycle)
+            {
+                lifecycle.Subscribe(
+                    this.stage,
+                    cancellation => this.scheduler.QueueTask(
+                        () => this.startupTask(this.serviceProvider, cancellation),
+                        this.schedulingTarget.SchedulingContext));
+            }
+        }
+    }
+}

src/Orleans.Runtime/Silo/Silo.cs

@@ -361,8 +361,11 @@ await scheduler.QueueAction(catalog.Start, catalog.SchedulingContext)
 
             // SystemTarget for provider init calls
             this.fallbackScheduler = Services.GetRequiredService<FallbackSystemTarget>();
-
             RegisterSystemTarget(fallbackScheduler);
+
+            // SystemTarget for startup tasks
+            var startupTaskTarget = Services.GetRequiredService<StartupTaskSystemTarget>();
+            RegisterSystemTarget(startupTaskTarget);
         }
 
         private Task OnRuntimeInitializeStart(CancellationToken ct)
@@ -869,5 +872,14 @@ public FallbackSystemTarget(ILocalSiloDetails localSiloDetails, ILoggerFactory l
         {
         }
     }
+
+    // A dummy system target for scheduling startup tasks.
+    internal class StartupTaskSystemTarget : SystemTarget
+    {
+        public StartupTaskSystemTarget(ILocalSiloDetails localSiloDetails, ILoggerFactory loggerFactory)
+            : base(Constants.StartupTaskSystemTargetId, localSiloDetails.SiloAddress, loggerFactory)
+        {
+        }
+    }
 }
 

test/Tester/StartupTaskTests.cs

@@ -0,0 +1,82 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+using Microsoft.Extensions.DependencyInjection;
+
+using Orleans;
+using Orleans.Hosting;
+using Orleans.Runtime;
+using Orleans.TestingHost;
+
+using TestExtensions;
+
+using UnitTests.GrainInterfaces;
+
+using Xunit;
+
+namespace DefaultCluster.Tests
+{
+    [TestCategory("BVT"), TestCategory("Lifecycle")]
+    public class StartupTaskTests : IClassFixture<StartupTaskTests.Fixture>
+    {
+        public class Fixture : BaseTestClusterFixture
+        {
+            protected override void ConfigureTestCluster(TestClusterBuilder builder)
+            {
+                builder.ConfigureHostConfiguration(TestDefaultConfiguration.ConfigureHostConfiguration);
+                builder.AddSiloBuilderConfigurator<StartupTaskSiloConfigurator>();
+            }
+
+            private class StartupTaskSiloConfigurator : ISiloBuilderConfigurator
+            {
+                public void Configure(ISiloHostBuilder hostBuilder)
+                {
+                    hostBuilder.AddStartupTask<CallGrainStartupTask>();
+                    hostBuilder.AddStartupTask(
+                        async (services, cancellation) =>
+                        {
+                            var grainFactory = services.GetRequiredService<IGrainFactory>();
+                            var grain = grainFactory.GetGrain<ISimpleGrain>(98052);
+
+                            // Modify "A" to validate ordering of events.
+                            await grain.SetA(await grain.GetA() * 2);
+                        });
+                }
+            }
+        }
+
+        public class CallGrainStartupTask : IStartupTask
+        {
+            private readonly IGrainFactory grainFactory;
+
+            public CallGrainStartupTask(IGrainFactory grainFactory)
+            {
+                this.grainFactory = grainFactory;
+            }
+
+            public async Task Execute(CancellationToken cancellationToken)
+            {
+                var grain = this.grainFactory.GetGrain<ISimpleGrain>(98052);
+                await grain.SetA(1331);
+            }
+        }
+
+        private readonly Fixture fixture;
+
+        public StartupTaskTests(Fixture fixture)
+        {
+            this.fixture = fixture;
+        }
+
+        /// <summary>
+        /// Ensures that startup tasks can call grains and are executed in the registered order.
+        /// </summary>
+        [Fact]
+        public async Task StartupTaskCanCallGrains()
+        {
+            var grain = this.fixture.GrainFactory.GetGrain<ISimpleGrain>(98052);
+            var value = await grain.GetA();
+            Assert.Equal(2662, value);
+        }
+    }
+}