feedback

Author: pavelsavara

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

@@ -30,6 +30,7 @@ internal partial class CircuitHost : IAsyncDisposable
     private CircuitHandler[] _circuitHandlers;
     private bool _initialized;
     private bool _isFirstUpdate = true;
+    private bool _onConnectionDownFired;
     private bool _disposed;
     private long _startTime;
     private PersistedCircuitState _persistedCircuitState;
@@ -188,16 +189,6 @@ public Task InitializeAsync(ProtectedPrerenderComponentApplicationStore store, A
         }));
     }
 
-    public bool SetDisconnected()
-    {
-        if (Client.Connected)
-        {
-            Client.SetDisconnected();
-            return true;
-        }
-        return false;
-    }
-
     // We handle errors in DisposeAsync because there's no real value in letting it propagate.
     // We run user code here (CircuitHandlers) and it's reasonable to expect some might throw, however,
     // there isn't anything better to do than log when one of these exceptions happens - because the
@@ -219,10 +210,7 @@ await Renderer.Dispatcher.InvokeAsync(async () =>
 
             try
             {
-                if (this.Client.Connected)
-                {
-                    await OnConnectionDownAsync(CancellationToken.None);
-                }
+                await OnConnectionDownAsync(CancellationToken.None);
             }
             catch
             {
@@ -292,6 +280,7 @@ private async Task OnCircuitOpenedAsync(CancellationToken cancellationToken)
 
     public async Task OnConnectionUpAsync(CancellationToken cancellationToken)
     {
+        _onConnectionDownFired = false;
         Log.ConnectionUp(_logger, CircuitId, Client.ConnectionId);
         _circuitMetrics?.OnConnectionUp();
 
@@ -322,6 +311,12 @@ public async Task OnConnectionUpAsync(CancellationToken cancellationToken)
 
     public async Task OnConnectionDownAsync(CancellationToken cancellationToken)
     {
+        if(_onConnectionDownFired)
+        {
+            return;
+        }
+
+        _onConnectionDownFired = true;
         Log.ConnectionDown(_logger, CircuitId, Client.ConnectionId);
         _circuitMetrics?.OnConnectionDown();
 

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

@@ -135,12 +135,12 @@ protected virtual bool DisconnectCore(CircuitHost circuitHost, string connection
         var result = ConnectedCircuits.TryRemove(circuitId, out circuitHost);
         Debug.Assert(result, "This operation operates inside of a lock. We expect the previously inspected value to be still here.");
 
-        var previouslyConnected = circuitHost.SetDisconnected();
+        circuitHost.Client.SetDisconnected();
         RegisterDisconnectedCircuit(circuitHost);
 
         Log.CircuitMarkedDisconnected(_logger, circuitId);
 
-        return previouslyConnected;
+        return true;
     }
 
     public void RegisterDisconnectedCircuit(CircuitHost circuitHost)
@@ -309,13 +309,9 @@ private Task PauseAndDisposeCircuitEntry(DisconnectedCircuitEntry entry)
 
     private async Task PauseAndDisposeCircuitHost(CircuitHost circuitHost, bool saveStateToClient)
     {
-        if (circuitHost.SetDisconnected())
-        {
-            await circuitHost.Renderer.Dispatcher.InvokeAsync(() => circuitHost.OnConnectionDownAsync(default));
-        }
-
         await _circuitPersistenceManager.PauseCircuitAsync(circuitHost, saveStateToClient);
         circuitHost.UnhandledException -= CircuitHost_UnhandledException;
+        circuitHost.Client.SetDisconnected();
         await circuitHost.DisposeAsync();
     }
 
@@ -381,12 +377,10 @@ private void DisposeTokenSource(DisconnectedCircuitEntry entry)
     }
 
     // We don't expect this to throw. User code only runs inside DisposeAsync and that does its own error handling.
-    public async ValueTask TerminateAsync(CircuitId circuitId)
+    public ValueTask TerminateAsync(CircuitId circuitId)
     {
         CircuitHost circuitHost;
         DisconnectedCircuitEntry entry = default;
-        var circuitHandlerTask = Task.CompletedTask;
-
         lock (CircuitRegistryLock)
         {
             if (ConnectedCircuits.TryGetValue(circuitId, out circuitHost) || DisconnectedCircuits.TryGetValue(circuitId.Secret, out entry))
@@ -395,21 +389,17 @@ public async ValueTask TerminateAsync(CircuitId circuitId)
                 DisconnectedCircuits.Remove(circuitId.Secret);
                 ConnectedCircuits.TryRemove(circuitId, out _);
                 Log.CircuitDisconnectedPermanently(_logger, circuitHost.CircuitId);
-
-                if (circuitHost.SetDisconnected())
-                {
-                    circuitHandlerTask = circuitHost.Renderer.Dispatcher.InvokeAsync(() => circuitHost.OnConnectionDownAsync(default));
-                }
+                circuitHost.Client.SetDisconnected();
             }
         }
 
-        await circuitHandlerTask;
-
         if (circuitHost != null)
         {
             circuitHost.UnhandledException -= CircuitHost_UnhandledException;
-            await circuitHost.DisposeAsync();
+            return circuitHost.DisposeAsync();
         }
+
+        return default;
     }
 
     // We don't need to do anything with the exception here, logging and sending exceptions to the client