stuff

Author: javiercn

src/Components/Server/src/Circuits/CircuitClientProxy.cs

@@ -5,14 +5,14 @@
 
 namespace Microsoft.AspNetCore.Components.Server.Circuits;
 
-internal sealed class CircuitClientProxy : IClientProxy
+internal sealed class CircuitClientProxy : ISingleClientProxy
 {
     public CircuitClientProxy()
     {
         Connected = false;
     }
 
-    public CircuitClientProxy(IClientProxy clientProxy, string connectionId)
+    public CircuitClientProxy(ISingleClientProxy clientProxy, string connectionId)
     {
         Transfer(clientProxy, connectionId);
     }
@@ -21,9 +21,9 @@ public CircuitClientProxy(IClientProxy clientProxy, string connectionId)
 
     public string ConnectionId { get; private set; }
 
-    public IClientProxy Client { get; private set; }
+    public ISingleClientProxy Client { get; private set; }
 
-    public void Transfer(IClientProxy clientProxy, string connectionId)
+    public void Transfer(ISingleClientProxy clientProxy, string connectionId)
     {
         Client = clientProxy ?? throw new ArgumentNullException(nameof(clientProxy));
         ConnectionId = connectionId ?? throw new ArgumentNullException(nameof(connectionId));

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

@@ -891,6 +891,11 @@ internal PersistedCircuitState TakePersistedCircuitState()
         return result;
     }
 
+    internal async Task<bool> SendPersistedStateToClient(string rootComponents, string applicationState)
+    {
+        return Client.SendAsync("JS.SavePersistedState", rootComponents, applicationState);
+    }
+
     private static partial class Log
     {
         // 100s used for lifecycle stuff

src/Components/Server/src/Circuits/CircuitPersistenceManager.cs

@@ -19,7 +19,7 @@ internal partial class CircuitPersistenceManager(
     IDataProtectionProvider dataProtectionProvider)
 {
 
-    public async Task PauseCircuitAsync(CircuitHost circuit, CancellationToken cancellation = default)
+    public async Task PauseCircuitAsync(CircuitHost circuit, bool saveStateToClient, CancellationToken cancellation = default)
     {
         var renderer = circuit.Renderer;
         var persistenceManager = circuit.Services.GetRequiredService<ComponentStatePersistenceManager>();
@@ -29,12 +29,51 @@ public async Task PauseCircuitAsync(CircuitHost circuit, CancellationToken cance
         var store = new CircuitPersistenceManagerStore();
         await persistenceManager.PersistStateAsync(store, renderer);
 
+        if (saveStateToClient)
+        {
+            _ = SaveStateToClient(circuit, store.PersistedCircuitState, cancellation);
+        }
+
         await circuitPersistenceProvider.PersistCircuitAsync(
             circuit.CircuitId,
             store.PersistedCircuitState,
             cancellation);
     }
 
+    private async Task SaveStateToClient(CircuitHost circuit, PersistedCircuitState state, CancellationToken cancellation = default)
+    {
+        var (rootComponents, applicationState) = ToProtectedState(state);
+        try
+        {
+            // Try to push the state to the client first, if that fails, we will persist it in the server-side store.
+            bool succeded = await circuit.SendPersistedStateToClient(rootComponents, applicationState);
+            if (!succeded)
+            {
+                try
+                {
+                    await circuitPersistenceProvider.PersistCircuitAsync(
+                        circuit.CircuitId,
+                        state,
+                        cancellation);
+                }
+                catch (Exception)
+                {
+                    // At this point, we give up as we haven't been able to save the state to the client nor the server.
+                    return;
+                }
+            }
+        }
+        catch (Exception)
+        {
+            // The call to save the state to the client failed, so fallback to saving it on the server.
+            // The client can still try to resume later without the state.
+            await circuitPersistenceProvider.PersistCircuitAsync(
+                circuit.CircuitId,
+                state,
+                cancellation);
+        }
+    }
+
     private Task PersistRootComponents(RemoteRenderer renderer, PersistentComponentState state)
     {
         var persistedComponents = new Dictionary<int, ComponentMarker>();
@@ -84,7 +123,7 @@ internal static RootComponentOperationBatch ToRootComponentOperationBatch(
             return null;
         }
 
-        var data = JsonSerializer.Deserialize<Dictionary<int,ComponentMarker>>(
+        var data = JsonSerializer.Deserialize<Dictionary<int, ComponentMarker>>(
             rootComponents,
             JsonSerializerOptionsProvider.Options);
 

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

@@ -287,16 +287,22 @@ private async Task PauseAndDisposeCircuitEntry(DisconnectedCircuitEntry entry)
 
         try
         {
-            await _circuitPersistenceManager.PauseCircuitAsync(entry.CircuitHost);
-            entry.CircuitHost.UnhandledException -= CircuitHost_UnhandledException;
-            await entry.CircuitHost.DisposeAsync();
+            var circuitHost = entry.CircuitHost;
+            await PauseAndDisposeCircuitHost(circuitHost, saveStateToClient: false);
         }
         catch (Exception ex)
         {
             Log.UnhandledExceptionDisposingCircuitHost(_logger, ex);
         }
     }
 
+    private async Task PauseAndDisposeCircuitHost(CircuitHost circuitHost, bool saveStateToClient)
+    {
+        await _circuitPersistenceManager.PauseCircuitAsync(circuitHost, saveStateToClient);
+        circuitHost.UnhandledException -= CircuitHost_UnhandledException;
+        await circuitHost.DisposeAsync();
+    }
+
     private void DisposeTokenSource(DisconnectedCircuitEntry entry)
     {
         try
@@ -353,6 +359,62 @@ private async void CircuitHost_UnhandledException(object sender, UnhandledExcept
         }
     }
 
+    internal Task PauseCircuitAsync(
+        CircuitHost circuitHost,
+        string connectionId)
+    {
+        Log.CircuitPauseStarted(_logger, circuitHost.CircuitId, connectionId);
+
+        Task circuitHandlerTask;
+        lock (CircuitRegistryLock)
+        {
+            if (PauseCore(circuitHost, connectionId))
+            {
+                circuitHandlerTask = circuitHost.Renderer.Dispatcher.InvokeAsync(() => circuitHost.OnConnectionDownAsync(default));
+            }
+            else
+            {
+                // DisconnectCore may fail to disconnect the circuit if it was previously marked inactive or
+                // has been transferred to a new connection. Do not invoke the circuit handlers in this instance.
+
+                // We have to do in this instance.
+                return Task.CompletedTask;
+            }
+        }
+
+        return circuitHandlerTask;
+    }
+
+    internal bool PauseCore(CircuitHost circuitHost, string connectionId)
+    {
+        var circuitId = circuitHost.CircuitId;
+        if (!ConnectedCircuits.TryGetValue(circuitId, out circuitHost))
+        {
+            Log.CircuitNotActive(_logger, circuitId);
+
+            // Circuit should be in the connected state for pausing.
+            return false;
+        }
+
+        if (!string.Equals(circuitHost.Client.ConnectionId, connectionId, StringComparison.Ordinal))
+        {
+            // Circuit should be connected to the same connection for pausing.
+            Log.CircuitConnectedToDifferentConnection(_logger, circuitId, circuitHost.Client.ConnectionId);
+
+            // The circuit is associated with a different connection. One way this could happen is when
+            // the client reconnects with a new connection before the OnDisconnect for the older
+            // connection is executed. Do nothing
+            return false;
+        }
+
+        var removeResult = ConnectedCircuits.TryRemove(circuitId, out _);
+        Debug.Assert(removeResult, "This operation operates inside of a lock. We expect the previously inspected value to be still here.");
+
+        _ = PauseAndDisposeCircuitHost(circuitHost, saveStateToClient: true);
+
+        return removeResult;
+    }
+
     private readonly struct DisconnectedCircuitEntry
     {
         public DisconnectedCircuitEntry(CircuitHost circuitHost, CancellationTokenSource tokenSource)
@@ -417,5 +479,8 @@ public static void ExceptionDisposingTokenSource(ILogger logger, Exception excep
 
         [LoggerMessage(115, LogLevel.Debug, "Reconnect to circuit with id {CircuitId} succeeded.", EventName = "ReconnectionSucceeded")]
         public static partial void ReconnectionSucceeded(ILogger logger, CircuitId circuitId);
+
+        [LoggerMessage(116, LogLevel.Debug, "Pausing circuit with id {CircuitId} from connection {ConnectionId}.", EventName = "CircuitPauseStarted")]
+        public static partial void CircuitPauseStarted(ILogger logger, CircuitId circuitId, string connectionId);
     }
 }

src/Components/Server/src/ComponentHub.cs

@@ -238,6 +238,27 @@ public async ValueTask<bool> ConnectCircuit(string circuitIdSecret)
         return false;
     }
 
+    public async ValueTask<string> PauseCircuit()
+    {
+        var circuitHost = await GetActiveCircuitAsync();
+        if (circuitHost == null)
+        {
+            return null;
+        }
+
+        // What needs to happen
+        // Disconnect the circuit
+        // Evict the circuit from the registry
+        // Capture the state during eviction
+        // Return the state to the client
+        // Close the connection (or have the client do it)
+
+        // Dissociate the circuit from the connection. From this point any new calls to the hub will fail to find the circuit.
+        _circuitHandleRegistry.SetCircuit(Context.Items, CircuitKey, circuitHost: null);
+        _ = _circuitRegistry.PauseCircuitAsync(circuitHost, Context.ConnectionId);
+        return null;
+    }
+
     // This method drives the resumption of a circuit that has been previously paused and ejected out of memory.
     // Resuming a circuit is very similar to starting a new circuit.
     // We receive an existing circuit ID to look up the existing circuit state.
@@ -323,12 +344,13 @@ public async ValueTask<string> ResumeCircuit(
                 return null;
             }
         }
-        else if (!string.IsNullOrEmpty(rootComponents) || !string.IsNullOrEmpty(applicationState))
+        else if ((rootComponents != "[]" && string.IsNullOrEmpty(applicationState)) ||
+            (rootComponents == "[]" && !string.IsNullOrEmpty(applicationState)))
         {
             Log.InvalidInputData(_logger);
             await NotifyClientError(
                 Clients.Caller,
-                string.IsNullOrEmpty(rootComponents) ?
+                rootComponents != "[]" ?
                 "The root components provided are invalid." :
                 "The application state provided is invalid."
             );

src/Components/Web.JS/src/Boot.Server.Common.ts

@@ -67,6 +67,20 @@ async function startServerCore(components: RootComponentManager<ServerComponentD
     return true;
   };
 
+  Blazor.pause = async () => {
+    if (circuit.didRenderingFail()) {
+      // We can't pause after a failure, so exit early.
+      return false;
+    }
+
+    if (!(await circuit.pause())) {
+      logger.log(LogLevel.Information, 'Pause attempt to the circuit was rejected by the server. This may indicate that the associated state is no longer available on the server.');
+      return false;
+    }
+
+    return true;
+  };
+
   Blazor.resume = async () => {
     if (circuit.didRenderingFail()) {
       // We can't resume after a failure, so exit early.
@@ -81,6 +95,7 @@ async function startServerCore(components: RootComponentManager<ServerComponentD
     return true;
   };
 
+
   Blazor.defaultReconnectionHandler = new DefaultReconnectionHandler(logger);
   options.reconnectionHandler = options.reconnectionHandler || Blazor.defaultReconnectionHandler;
 

src/Components/Web.JS/src/GlobalExports.ts

@@ -38,6 +38,7 @@ export interface IBlazor {
   removeEventListener?: typeof JSEventRegistry.prototype.removeEventListener;
   disconnect?: () => void;
   reconnect?: (existingConnection?: HubConnection) => Promise<boolean>;
+  pause?: (existingConnection?: HubConnection) => Promise<boolean>;
   resume?: (existingConnection?: HubConnection) => Promise<boolean>;
   defaultReconnectionHandler?: DefaultReconnectionHandler;
   start?: ((userOptions?: Partial<CircuitStartOptions>) => Promise<void>) | ((options?: Partial<WebAssemblyStartOptions>) => Promise<void>) | ((options?: Partial<WebStartOptions>) => Promise<void>);

src/Components/Web.JS/src/Platform/Circuits/CircuitManager.ts

@@ -49,6 +49,8 @@ export class CircuitManager implements DotNet.DotNetCallDispatcher {
 
   private _disposed = false;
 
+  private _persistedCircuitState?: { components: string, applicationState: string };
+
   public constructor(
     componentManager: RootComponentManager<ServerComponentDescriptor>,
     appState: string,
@@ -235,17 +237,25 @@ export class CircuitManager implements DotNet.DotNetCallDispatcher {
 
   public async resume(): Promise<boolean> {
     if (!this._circuitId) {
-      throw new Error('Method not implemented.');
+      throw new Error('Circuit host not initialized.');
     }
 
+    if (this._connection!.state !== HubConnectionState.Connected) {
+      return false;
+    }
+
+    const persistedCircuitState = this._persistedCircuitState;
+    this._persistedCircuitState = undefined;
+
     const resume = await this._connection!.invoke<string>(
       'ResumeCircuit',
       this._circuitId,
       navigationManagerFunctions.getBaseURI(),
       navigationManagerFunctions.getLocationHref(),
-      '[]',
-      ''
+      persistedCircuitState?.components ?? '[]',
+      persistedCircuitState?.applicationState ?? '',
     );
+
     if (!resume) {
       return false;
     }
@@ -254,10 +264,34 @@ export class CircuitManager implements DotNet.DotNetCallDispatcher {
     this._renderQueue = new RenderQueue(this._logger);
     this._options.reconnectionHandler!.onCircuitResumed();
     this._options.reconnectionHandler!.onConnectionUp();
-    this._componentManager.onComponentReload?.();
+    this._componentManager.onComponentReload?.(WebRendererId.Server);
     return true;
   }
 
+  public async pause() {
+    if (!this._circuitId) {
+      throw new Error('Method not implemented.');
+    }
+
+    if (this._connection!.state !== HubConnectionState.Connected) {
+      return false;
+    }
+
+    const pauseResult = await this._connection!.invoke<string>(
+      'PauseCircuit',
+      this._circuitId,
+    );
+
+    if (!pauseResult) {
+      return false;
+    }
+
+    this._persistedCircuitState = JSON.parse(pauseResult);
+
+    this._options.reconnectionHandler!.onCircuitPaused();
+  }
+
+
   // Implements DotNet.DotNetCallDispatcher
   public beginInvokeDotNetFromJS(callId: number, assemblyName: string | null, methodIdentifier: string, dotNetObjectId: number | null, argsJson: string): void {
     this.throwIfDispatchingWhenDisposed();

src/Components/Web.JS/src/Platform/Circuits/CircuitStartOptions.ts

@@ -48,6 +48,7 @@ export interface ReconnectionHandler {
   onConnectionDown(options: ReconnectionOptions, error?: Error): void;
   onConnectionUp(): void;
   onCircuitResumed(): void;
+  onCircuitPaused(): void;
 }
 
 function computeDefaultRetryInterval(previousAttempts: number, maxRetries?: number): number | null {

src/Components/Web.JS/src/Platform/Circuits/DefaultReconnectionHandler.ts

@@ -55,6 +55,10 @@ export class DefaultReconnectionHandler implements ReconnectionHandler {
   onCircuitResumed(): void {
     return;
   }
+
+  onCircuitPaused(): void {
+    return;
+  }
 }
 
 class ReconnectionProcess {