[Design]: Introduce CircuitHandler to handle circuit lifetime events

Partial fix to #6353

Author: pranavkm

src/Components/Server/src/Builder/RazorComponentsApplicationBuilderExtensions.cs

@@ -50,7 +50,7 @@ public static IApplicationBuilder UseRazorComponents<TStartup>(
             // add SignalR and BlazorHub automatically.
             if (options.UseSignalRWithBlazorHub)
             {
-                builder.UseSignalR(route => route.MapHub<BlazorHub>(BlazorHub.DefaultPath));
+                builder.UseSignalR(route => route.MapHub<ComponentsHub>(ComponentsHub.DefaultPath));
             }
 
             // Use embedded static content for /_framework

src/Components/Server/src/Builder/ServerSideBlazorApplicationBuilder.cs renamed to src/Components/Server/src/Builder/ServerSideComponentsApplicationBuilder.cs

@@ -7,9 +7,9 @@
 
 namespace Microsoft.AspNetCore.Components.Hosting
 {
-    internal class ServerSideBlazorApplicationBuilder : IComponentsApplicationBuilder
+    internal class ServerSideComponentsApplicationBuilder : IComponentsApplicationBuilder
     {
-        public ServerSideBlazorApplicationBuilder(IServiceProvider services)
+        public ServerSideComponentsApplicationBuilder(IServiceProvider services)
         {
             Services = services;
             Entries = new List<(Type componentType, string domElementSelector)>();

src/Components/Server/src/Circuits/Circuit.cs

@@ -1,35 +1,21 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
-using System;
-using Microsoft.JSInterop;
-
 namespace Microsoft.AspNetCore.Components.Server.Circuits
 {
     /// <summary>
-    /// Represents an active connection between a Blazor server and a client.
+    /// Represents an active connection between an ASP.NET Core Component on the server and a client.
     /// </summary>
     public class Circuit
     {
-        /// <summary>
-        /// Gets the current <see cref="Circuit"/>.
-        /// </summary>
-        public static Circuit Current => CircuitHost.Current?.Circuit;
-
-        internal Circuit(CircuitHost circuitHost)
+        internal Circuit(string id)
         {
-            JSRuntime = circuitHost.JSRuntime;
-            Services = circuitHost.Services;
+            Id = id;
         }
 
         /// <summary>
-        /// Gets the <see cref="IJSRuntime"/> associated with this circuit.
-        /// </summary>
-        public IJSRuntime JSRuntime { get; }
-
-        /// <summary>
-        /// Gets the <see cref="IServiceProvider"/> associated with this circuit.
+        /// Gets the identifier for the <see cref="Circuit"/>.
         /// </summary>
-        public IServiceProvider Services { get; }
+        public string Id { get; }
     }
 }

src/Components/Server/src/Circuits/CircuitHandler.cs

@@ -0,0 +1,76 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.Components.Server.Circuits
+{
+    /// <summary>
+    /// A <see cref="CircuitHandler"/> allows running code during specific lifetime events of a <see cref="Circuit"/>.
+    /// <list type="bullet">
+    /// <item>
+    /// <see cref="OnCircuitOpenedAsync(Circuit, CancellationToken)"/> is invoked after an initial connection to the client
+    /// has been established.
+    /// </item>
+    /// <item>
+    /// <see cref="OnConnectionUpAsync(Circuit, CancellationToken)(Circuit, CancellationToken)"/> is invoked immediately after the completion of
+    /// <see cref="OnCircuitOpenedAsync(Circuit, CancellationToken)"/>. In addition, the method is invoked each time a connection is re-established
+    /// with a client after it's been dropped. <see cref="OnConnectionDownAsync(Circuit, CancellationToken)"/> is invoked each time a connection
+    /// is dropped.
+    /// </item>
+    /// <item>
+    /// <see cref="OnCircuitClosedAsync(Circuit, CancellationToken)"/> is invoked prior to the server evicting the connection to the client.
+    /// Application users may use this event to save state for a client that can be later rehydrated.
+    /// </item>
+    /// </list>
+    /// <ol>
+    /// </summary>
+    public abstract class CircuitHandler
+    {
+        internal static readonly CircuitHandler NullHandler = new NullCircuitHandler();
+
+        /// <summary>
+        /// Invoked when a new circuit was established.
+        /// </summary>
+        /// <param name="circuit">The <see cref="Circuit"/>.</param>
+        /// <param name="cts">The <see cref="CancellationToken"/>.</param>
+        /// <returns><see cref="Task"/> that represents the asynchronous execution operation.</returns>
+        public virtual Task OnCircuitOpenedAsync(Circuit circuit, CancellationToken cts) => Task.CompletedTask;
+
+        /// <summary>
+        /// Invoked when a connection to the client was established.
+        /// <para>
+        /// This method is executed once initially after <see cref="OnCircuitOpenedAsync(Circuit, CancellationToken)"/>
+        /// and once each for each reconnect during the lifetime of a circuit.
+        /// </para>
+        /// </summary>
+        /// <param name="circuit">The <see cref="Circuit"/>.</param>
+        /// <param name="cts">The <see cref="CancellationToken"/>.</param>
+        /// <returns><see cref="Task"/> that represents the asynchronous execution operation.</returns>
+        public virtual Task OnConnectionUpAsync(Circuit circuit, CancellationToken cts) => Task.CompletedTask;
+
+        /// <summary>
+        /// Invoked a connection to the client using was dropped.
+        /// </summary>
+        /// <param name="circuit">The <see cref="Circuit"/>.</param>
+        /// <param name="cts">The <see cref="CancellationToken"/>.</param>
+        /// <returns><see cref="Task"/> that represents the asynchronous execution operation.</returns>
+        public virtual Task OnConnectionDownAsync(Circuit circuit, CancellationToken cts) => Task.CompletedTask;
+
+
+        /// <summary>
+        /// Invoked when a new circuit is being discarded.
+        /// </summary>
+        /// <param name="circuit">The <see cref="Circuit"/>.</param>
+        /// <param name="cts">The <see cref="CancellationToken"/>.</param>
+        /// <returns><see cref="Task"/> that represents the asynchronous execution operation.</returns>
+        public virtual Task OnCircuitClosedAsync(Circuit circuit, CancellationToken cts) => Task.CompletedTask;
+
+        private class NullCircuitHandler : CircuitHandler
+        {
+
+        }
+    }
+}

src/Components/Server/src/Circuits/CircuitHost.cs

@@ -14,9 +14,12 @@
 
 namespace Microsoft.AspNetCore.Components.Server.Circuits
 {
-    internal class CircuitHost : IDisposable
+    internal class CircuitHost : IAsyncDisposable
     {
         private static readonly AsyncLocal<CircuitHost> _current = new AsyncLocal<CircuitHost>();
+        private readonly IServiceScope _scope;
+        private Action<IComponentsApplicationBuilder> _configure;
+        private bool _isInitialized;
 
         /// <summary>
         /// Gets the current <see cref="Circuit"/>, if any.
@@ -37,25 +40,24 @@ public static void SetCurrentCircuitHost(CircuitHost circuitHost)
         {
             _current.Value = circuitHost ?? throw new ArgumentNullException(nameof(circuitHost));
 
-            Microsoft.JSInterop.JSRuntime.SetCurrentJSRuntime(circuitHost.JSRuntime);
+            JSInterop.JSRuntime.SetCurrentJSRuntime(circuitHost.JSRuntime);
             RendererRegistry.SetCurrentRendererRegistry(circuitHost.RendererRegistry);
         }
 
         public event UnhandledExceptionEventHandler UnhandledException;
 
-        private bool _isInitialized;
-        private Action<IComponentsApplicationBuilder> _configure;
-
         public CircuitHost(
             IServiceScope scope,
             IClientProxy client,
             RendererRegistry rendererRegistry,
             RemoteRenderer renderer,
             Action<IComponentsApplicationBuilder> configure,
             IJSRuntime jsRuntime,
-            CircuitSynchronizationContext synchronizationContext)
+            CircuitSynchronizationContext synchronizationContext,
+            Circuit circuit,
+            CircuitHandler circuitHandler)
         {
-            Scope = scope ?? throw new ArgumentNullException(nameof(scope));
+            _scope = scope ?? throw new ArgumentNullException(nameof(scope));
             Client = client ?? throw new ArgumentNullException(nameof(client));
             RendererRegistry = rendererRegistry ?? throw new ArgumentNullException(nameof(rendererRegistry));
             Renderer = renderer ?? throw new ArgumentNullException(nameof(renderer));
@@ -65,7 +67,8 @@ public CircuitHost(
 
             Services = scope.ServiceProvider;
 
-            Circuit = new Circuit(this);
+            Circuit = circuit;
+            CircuitHandler = circuitHandler;
 
             Renderer.UnhandledException += Renderer_UnhandledException;
             SynchronizationContext.UnhandledException += SynchronizationContext_UnhandledException;
@@ -81,19 +84,21 @@ public CircuitHost(
 
         public RendererRegistry RendererRegistry { get; }
 
-        public IServiceScope Scope { get; }
-
         public IServiceProvider Services { get; }
 
         public CircuitSynchronizationContext SynchronizationContext { get; }
 
-        public async Task InitializeAsync()
+        public CircuitHandler CircuitHandler { get; }
+
+        public CancellationToken ConnectionAborted { get; }
+
+        public async Task InitializeAsync(CancellationToken cancellationToken)
         {
-            await SynchronizationContext.Invoke(() =>
+            await SynchronizationContext.InvokeAsync(async () =>
             {
                 SetCurrentCircuitHost(this);
 
-                var builder = new ServerSideBlazorApplicationBuilder(Services);
+                var builder = new ServerSideComponentsApplicationBuilder(Services);
 
                 _configure(builder);
 
@@ -102,6 +107,9 @@ await SynchronizationContext.Invoke(() =>
                     var entry = builder.Entries[i];
                     Renderer.AddComponent(entry.componentType, entry.domElementSelector);
                 }
+
+                await CircuitHandler.OnCircuitOpenedAsync(Circuit, cancellationToken);
+                await CircuitHandler.OnConnectionUpAsync(Circuit, cancellationToken);
             });
 
             _isInitialized = true;
@@ -126,9 +134,15 @@ await SynchronizationContext.Invoke(() =>
             }
         }
 
-        public void Dispose()
+        public async ValueTask DisposeAsync()
         {
-            Scope.Dispose();
+            await SynchronizationContext.InvokeAsync(async () =>
+            {
+                await CircuitHandler.OnConnectionDownAsync(Circuit, default);
+                await CircuitHandler.OnCircuitClosedAsync(Circuit, default);
+            });
+
+            _scope.Dispose();
             Renderer.Dispose();
         }
 

src/Components/Server/src/Circuits/DefaultCircuitFactory.cs

@@ -14,11 +14,11 @@ namespace Microsoft.AspNetCore.Components.Server.Circuits
     internal class DefaultCircuitFactory : CircuitFactory
     {
         private readonly IServiceScopeFactory _scopeFactory;
-        private readonly DefaultCircuitFactoryOptions _options;
+        private readonly ComponentsServerOptions _options;
 
         public DefaultCircuitFactory(
             IServiceScopeFactory scopeFactory,
-            IOptions<DefaultCircuitFactoryOptions> options)
+            IOptions<ComponentsServerOptions> options)
         {
             if (options == null)
             {
@@ -33,30 +33,53 @@ public override CircuitHost CreateCircuitHost(HttpContext httpContext, IClientPr
         {
             if (!_options.StartupActions.TryGetValue(httpContext.Request.Path, out var config))
             {
-                var message = $"Could not find a Blazor startup action for request path {httpContext.Request.Path}";
+                var message = $"Could not find an ASP.NET Core Components startup action for request path '{httpContext.Request.Path}'.";
                 throw new InvalidOperationException(message);
             }
 
+            var circuit = new Circuit(Guid.NewGuid().ToString());
             var scope = _scopeFactory.CreateScope();
             var jsRuntime = new RemoteJSRuntime(client);
             var rendererRegistry = new RendererRegistry();
             var synchronizationContext = new CircuitSynchronizationContext();
             var renderer = new RemoteRenderer(scope.ServiceProvider, rendererRegistry, jsRuntime, client, synchronizationContext);
 
+            var circuitHandler = GetCircuitHandler(httpContext, scope);
+
             var circuitHost = new CircuitHost(
                 scope,
                 client,
                 rendererRegistry,
                 renderer,
                 config,
                 jsRuntime,
-                synchronizationContext);
+                synchronizationContext,
+                circuit,
+                circuitHandler);
 
             // Initialize per-circuit data that services need
             (circuitHost.Services.GetRequiredService<IJSRuntimeAccessor>() as DefaultJSRuntimeAccessor).JSRuntime = jsRuntime;
             (circuitHost.Services.GetRequiredService<ICircuitAccessor>() as DefaultCircuitAccessor).Circuit = circuitHost.Circuit;
 
             return circuitHost;
         }
+
+        private CircuitHandler GetCircuitHandler(HttpContext httpContext, IServiceScope scope)
+        {
+            // Is there a specific handler for this component hub?
+            if (!_options.CircuitHandlers.TryGetValue(httpContext.Request.Path, out var handlerType))
+            {
+                // Nope, perhaps there's a default one specified.
+                handlerType = _options.DefaultCircuitHandler;
+            }
+
+            var circuitHandler = CircuitHandler.NullHandler;
+            if (handlerType != null)
+            {
+                circuitHandler = (CircuitHandler)scope.ServiceProvider.GetRequiredService(handlerType);
+            }
+
+            return circuitHandler;
+        }
     }
 }

src/Components/Server/src/Circuits/DefaultCircuitFactoryOptions.cs

@@ -48,7 +48,7 @@ public void Initialize(string uriAbsolute, string baseUriAbsolute)
         [JSInvokable(nameof(NotifyLocationChanged))]
         public static void NotifyLocationChanged(string uriAbsolute)
         {
-            var circuit = Circuit.Current;
+            var circuit = CircuitHost.Current;
             if (circuit == null)
             {
                 var message = $"{nameof(NotifyLocationChanged)} called without a circuit.";