Wire up the default handler

Author: javiercn

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

@@ -67,6 +67,20 @@ async function startServerCore(components: RootComponentManager<ServerComponentD
     return true;
   };
 
+  Blazor.resume = async () => {
+    if (circuit.didRenderingFail()) {
+      // We can't resume after a failure, so exit early.
+      return false;
+    }
+
+    if (!(await circuit.resume())) {
+      logger.log(LogLevel.Information, 'Resume 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.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>;
+  resume?: (existingConnection?: HubConnection) => Promise<boolean>;
   defaultReconnectionHandler?: DefaultReconnectionHandler;
   start?: ((userOptions?: Partial<CircuitStartOptions>) => Promise<void>) | ((options?: Partial<WebAssemblyStartOptions>) => Promise<void>) | ((options?: Partial<WebStartOptions>) => Promise<void>);
   platform?: Platform;

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

@@ -20,6 +20,7 @@ import { attachWebRendererInterop, detachWebRendererInterop } from '../../Render
 import { sendJSDataStream } from './CircuitStreamingInterop';
 
 export class CircuitManager implements DotNet.DotNetCallDispatcher {
+
   private readonly _componentManager: RootComponentManager<ServerComponentDescriptor>;
 
   private _applicationState: string;
@@ -224,28 +225,36 @@ export class CircuitManager implements DotNet.DotNetCallDispatcher {
     }
 
     if (!await this._connection!.invoke<boolean>('ConnectCircuit', this._circuitId)) {
-      const resume = await this._connection!.invoke<string>(
-        'ResumeCircuit',
-        this._circuitId,
-        navigationManagerFunctions.getBaseURI(),
-        navigationManagerFunctions.getLocationHref(),
-        '[]',
-        ''
-      );
-      if (!resume) {
-        detachWebRendererInterop(WebRendererId.Server);
-        this._interopMethodsForReconnection = undefined;
-        return false;
-      }
+      return false;
+    }
 
-      this._circuitId = resume;
-      this._renderQueue = new RenderQueue(this._logger);
+    this._options.reconnectionHandler!.onConnectionUp();
 
-      this._componentManager.onComponentReload?.();
+    return true;
+  }
+
+  public async resume(): Promise<boolean> {
+    if (!this._circuitId) {
+      throw new Error('Method not implemented.');
     }
 
-    this._options.reconnectionHandler!.onConnectionUp();
+    const resume = await this._connection!.invoke<string>(
+      'ResumeCircuit',
+      this._circuitId,
+      navigationManagerFunctions.getBaseURI(),
+      navigationManagerFunctions.getLocationHref(),
+      '[]',
+      ''
+    );
+    if (!resume) {
+      return false;
+    }
 
+    this._circuitId = resume;
+    this._renderQueue = new RenderQueue(this._logger);
+    this._options.reconnectionHandler!.onCircuitResumed();
+    this._options.reconnectionHandler!.onConnectionUp();
+    this._componentManager.onComponentReload?.();
     return true;
   }
 

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

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

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

@@ -13,14 +13,17 @@ export class DefaultReconnectionHandler implements ReconnectionHandler {
 
   private readonly _reconnectCallback: () => Promise<boolean>;
 
+  private readonly _resumeCallback: () => Promise<boolean>;
+
   private _currentReconnectionProcess: ReconnectionProcess | null = null;
 
   private _reconnectionDisplay?: ReconnectDisplay;
 
-  constructor(logger: Logger, overrideDisplay?: ReconnectDisplay, reconnectCallback?: () => Promise<boolean>) {
+  constructor(logger: Logger, overrideDisplay?: ReconnectDisplay, reconnectCallback?: () => Promise<boolean>, resumeCallback?: () => Promise<boolean>) {
     this._logger = logger;
     this._reconnectionDisplay = overrideDisplay;
     this._reconnectCallback = reconnectCallback || Blazor.reconnect!;
+    this._resumeCallback = resumeCallback || Blazor.resume!;
   }
 
   onConnectionDown(options: ReconnectionOptions, _error?: Error): void {
@@ -32,7 +35,13 @@ export class DefaultReconnectionHandler implements ReconnectionHandler {
     }
 
     if (!this._currentReconnectionProcess) {
-      this._currentReconnectionProcess = new ReconnectionProcess(options, this._logger, this._reconnectCallback, this._reconnectionDisplay);
+      this._currentReconnectionProcess = new ReconnectionProcess(
+        options,
+        this._logger,
+        this._reconnectCallback,
+        this._resumeCallback,
+        this._reconnectionDisplay
+      );
     }
   }
 
@@ -42,6 +51,10 @@ export class DefaultReconnectionHandler implements ReconnectionHandler {
       this._currentReconnectionProcess = null;
     }
   }
+
+  onCircuitResumed(): void {
+    return;
+  }
 }
 
 class ReconnectionProcess {
@@ -51,7 +64,7 @@ class ReconnectionProcess {
 
   isDisposed = false;
 
-  constructor(options: ReconnectionOptions, private logger: Logger, private reconnectCallback: () => Promise<boolean>, display: ReconnectDisplay) {
+  constructor(options: ReconnectionOptions, private logger: Logger, private reconnectCallback: () => Promise<boolean>, private resumeCallback: () => Promise<boolean>, display: ReconnectDisplay) {
     this.reconnectDisplay = display;
     this.reconnectDisplay.show();
     this.attemptPeriodicReconnection(options);
@@ -65,7 +78,7 @@ class ReconnectionProcess {
   async attemptPeriodicReconnection(options: ReconnectionOptions) {
     for (let i = 0; options.maxRetries === undefined || i < options.maxRetries; i++) {
       let retryInterval: number;
-      if (typeof(options.retryIntervalMilliseconds) === 'function') {
+      if (typeof (options.retryIntervalMilliseconds) === 'function') {
         const computedRetryInterval = options.retryIntervalMilliseconds(i);
         if (computedRetryInterval === null || computedRetryInterval === undefined) {
           break;
@@ -92,6 +105,12 @@ class ReconnectionProcess {
         // - exception to mean we didn't reach the server (this can be sync or async)
         const result = await this.reconnectCallback();
         if (!result) {
+          // Try to resume the circuit if the reconnect failed
+          const resumeResult = await this.resumeCallback();
+          if (resumeResult) {
+            return;
+          }
+
           // If the server responded and refused to reconnect, stop auto-retrying.
           this.reconnectDisplay.rejected();
           return;