Graceful reconnection alternative

Author: javiercn

src/Components/Server/src/Builder/ComponentEndpointConventionBuilder.cs

@@ -10,11 +10,11 @@ namespace Microsoft.AspNetCore.Builder
     /// </summary>
     public sealed class ComponentEndpointConventionBuilder : IHubEndpointConventionBuilder
     {
-        private readonly IEndpointConventionBuilder _endpointConventionBuilder;
+        private readonly IEndpointConventionBuilder [] _endpointConventionBuilders;
 
-        internal ComponentEndpointConventionBuilder(IEndpointConventionBuilder endpointConventionBuilder)
+        internal ComponentEndpointConventionBuilder(params IEndpointConventionBuilder [] endpointConventionBuilder)
         {
-            _endpointConventionBuilder = endpointConventionBuilder;
+            _endpointConventionBuilders = endpointConventionBuilder;
         }
 
         /// <summary>
@@ -23,7 +23,10 @@ internal ComponentEndpointConventionBuilder(IEndpointConventionBuilder endpointC
         /// <param name="convention">The convention to add to the builder.</param>
         public void Add(Action<EndpointBuilder> convention)
         {
-            _endpointConventionBuilder.Add(convention);
+            foreach (var endpoint in _endpointConventionBuilders)
+            {
+                endpoint.Add(convention);
+            }
         }
     }
 }

src/Components/Server/src/Builder/ComponentEndpointRouteBuilderExtensions.cs

@@ -292,7 +292,17 @@ public static ComponentEndpointConventionBuilder MapBlazorHub(
                 throw new ArgumentNullException(nameof(configureOptions));
             }
 
-            return new ComponentEndpointConventionBuilder(endpoints.MapHub<ComponentHub>(path, configureOptions)).AddComponent(componentType, selector);
+            var hubEndpoint = endpoints.MapHub<ComponentHub>(path, configureOptions);
+
+            var disconnectEndpoint = endpoints.Map(
+                (path.EndsWith("/") ? path : path + "/") + "disconnect/",
+                endpoints.CreateApplicationBuilder().UseMiddleware<CircuitDisconnectMiddleware>().Build())
+                .WithDisplayName("Blazor disconnect");
+
+            return new ComponentEndpointConventionBuilder(
+                disconnectEndpoint,
+                hubEndpoint)
+                .AddComponent(componentType, selector);
         }
     }
 }

src/Components/Server/src/CircuitDisconnectMiddleware.cs

@@ -0,0 +1,80 @@
+// 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 System.Threading.Tasks;
+using Microsoft.AspNetCore.Components.Server.Circuits;
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.AspNetCore.Components.Server
+{
+    internal class CircuitDisconnectMiddleware
+    {
+        private const string CircuitIdKey = "circuitId";
+
+        public CircuitDisconnectMiddleware(
+            ILogger<CircuitDisconnectMiddleware> logger,
+            CircuitRegistry registry,
+            CircuitIdFactory circuitIdFactory,
+            RequestDelegate next)
+        {
+            Logger = logger;
+            Registry = registry;
+            CircuitIdFactory = circuitIdFactory;
+            Next = next;
+        }
+
+        public ILogger<CircuitDisconnectMiddleware> Logger { get; }
+        public CircuitRegistry Registry { get; }
+        public CircuitIdFactory CircuitIdFactory { get; }
+        public RequestDelegate Next { get; }
+
+        public async Task Invoke(HttpContext context)
+        {
+            if (!HttpMethods.IsPost(context.Request.Method))
+            {
+                context.Response.StatusCode = StatusCodes.Status405MethodNotAllowed;
+                return;
+            }
+
+            var form = await context.Request.ReadFormAsync();
+            if(!form.TryGetValue(CircuitIdKey, out var circuitId) || !CircuitIdFactory.ValidateCircuitId(circuitId))
+            {
+                context.Response.StatusCode = StatusCodes.Status404NotFound;
+                return;
+            }
+
+            await TerminateCircuitGracefully(circuitId);
+
+            context.Response.StatusCode = StatusCodes.Status200OK;
+            return;
+        }
+
+        private async Task TerminateCircuitGracefully(string circuitId)
+        {
+            try
+            {
+                Log.CircuitTerminatedGracefully(Logger, circuitId);
+                await Registry.Terminate(circuitId);
+            }
+            catch (Exception e)
+            {
+                Log.UnhandledExceptionInCircuit(Logger, circuitId, e);
+            }
+        }
+
+        private class Log
+        {
+            private static readonly Action<ILogger, string, Exception> _circuitTerminatedGracefully =
+                LoggerMessage.Define<string>(LogLevel.Debug, new EventId(1, "CircuitTerminatedGracefully"), "Circuit '{CircuitId}' terminated gracefully");
+
+            private static readonly Action<ILogger, string, Exception> _unhandledExceptionInCircuit =
+                LoggerMessage.Define<string>(LogLevel.Warning, new EventId(2, "UnhandledExceptionInCircuit"), "Unhandled exception in circuit {CircuitId} while terminating gracefully.");
+
+            public static void CircuitTerminatedGracefully(ILogger logger, string circuitId) => _circuitTerminatedGracefully(logger, circuitId, null);
+
+            public static void UnhandledExceptionInCircuit(ILogger logger, string circuitId, Exception exception) => _unhandledExceptionInCircuit(logger, circuitId, exception);
+        }
+    }
+}

src/Components/Server/src/Circuits/CircuitRegistry.cs

@@ -83,11 +83,10 @@ public void Register(CircuitHost circuitHost)
 
         public void PermanentDisconnect(CircuitHost circuitHost)
         {
-            if (ConnectedCircuits.TryRemove(circuitHost.CircuitId, out _))
-            {
-                Log.CircuitDisconnectedPermanently(_logger, circuitHost.CircuitId);
-                circuitHost.Client.SetDisconnected();
-            }
+            DisconnectedCircuits.Remove(circuitHost.CircuitId);
+            ConnectedCircuits.TryRemove(circuitHost.CircuitId, out _);
+            Log.CircuitDisconnectedPermanently(_logger, circuitHost.CircuitId);
+            circuitHost.Client.SetDisconnected();
         }
 
         public virtual Task DisconnectAsync(CircuitHost circuitHost, string connectionId)
@@ -297,6 +296,31 @@ private void DisposeTokenSource(DisconnectedCircuitEntry entry)
             }
         }
 
+        internal ValueTask Terminate(string circuitId)
+        {
+            CircuitHost circuitHost;
+            DisconnectedCircuitEntry entry = default;
+            lock (CircuitRegistryLock)
+            {
+                if (ConnectedCircuits.TryGetValue(circuitId, out circuitHost) || DisconnectedCircuits.TryGetValue(circuitId, out entry))
+                {
+                    PermanentDisconnect(circuitHost ?? entry.CircuitHost);
+                }
+                else
+                {
+                    return default;
+                }
+            }
+            if (circuitHost != null)
+            {
+                return circuitHost.DisposeAsync();
+            }
+            else
+            {
+                return default;
+            }
+        }
+
         private readonly struct DisconnectedCircuitEntry
         {
             public DisconnectedCircuitEntry(CircuitHost circuitHost, CancellationTokenSource tokenSource)

src/Components/Server/src/ComponentHub.cs

@@ -68,34 +68,7 @@ public override Task OnDisconnectedAsync(Exception exception)
                 return Task.CompletedTask;
             }
 
-            if (exception != null)
-            {
-                return _circuitRegistry.DisconnectAsync(circuitHost, Context.ConnectionId);
-            }
-            else
-            {
-                // The client will gracefully disconnect when using websockets by correctly closing the TCP connection.
-                // This happens when the user closes a tab, navigates away from the page or reloads the page.
-                // In these situations we know the user is done with the circuit, so we can get rid of it at that point.
-                // This is important to be able to more efficiently manage resources, specially memory.
-                return TerminateCircuitGracefully(circuitHost);
-            }
-        }
-
-        private async Task TerminateCircuitGracefully(CircuitHost circuitHost)
-        {
-            try
-            {
-                Log.CircuitTerminatedGracefully(_logger, circuitHost.CircuitId);
-                _circuitRegistry.PermanentDisconnect(circuitHost);
-                await circuitHost.DisposeAsync();
-            }
-            catch (Exception e)
-            {
-                Log.UnhandledExceptionInCircuit(_logger, circuitHost.CircuitId, e);
-            }
-
-            await _circuitRegistry.DisconnectAsync(circuitHost, Context.ConnectionId);
+            return _circuitRegistry.DisconnectAsync(circuitHost, Context.ConnectionId);
         }
 
         /// <summary>

src/Components/Server/test/ComponentEndpointRouteBuilderExtensionsTest.cs

@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Moq;
@@ -63,6 +64,7 @@ private IApplicationBuilder CreateAppBuilder()
             services.AddRouting();
             services.AddSignalR();
             services.AddServerSideBlazor();
+            services.AddSingleton<IConfiguration>(new ConfigurationBuilder().Build());
 
             var serviceProvder = services.BuildServiceProvider();
 

src/Components/Web.JS/dist/Release/blazor.server.js

@@ -47,9 +47,17 @@ async function boot(userOptions?: Partial<BlazorOptions>): Promise<void> {
     return true;
   };
 
+  window.addEventListener('unload', sendDisconnect, false);
+
   window['Blazor'].reconnect = reconnect;
 
   logger.log(LogLevel.Information, 'Blazor server-side application started.');
+
+  function sendDisconnect(_: Event): void {
+    const data = new FormData();
+    data.set('circuitId', circuit.circuitId);
+    navigator.sendBeacon(`${document.baseURI}_blazor/disconnect`, data);
+  }
 }
 
 async function initializeConnection(options: BlazorOptions, logger: Logger): Promise<signalR.HubConnection> {