tmp

Author: javiercn

src/Components/Server/src/ComponentHub.cs

@@ -209,33 +209,42 @@ public async Task UpdateRootComponents(string serializedComponentOperations, str
         _ = circuitHost.UpdateRootComponents(operations, store, Context.ConnectionAborted);
     }
 
-    public async ValueTask<bool> ConnectCircuit(string circuitIdSecret)
+    public void ConnectCircuit(string circuitIdSecret)
     {
         // TryParseCircuitId will not throw.
         if (!_circuitIdFactory.TryParseCircuitId(circuitIdSecret, out var circuitId))
         {
             // Invalid id.
             Log.InvalidCircuitId(_logger, circuitIdSecret);
-            return false;
+            _ = Clients.Caller.SendAsync("JS.EndConnectCircuit", false);
+            return;
         }
 
-        // ConnectAsync will not throw.
-        var circuitHost = await _circuitRegistry.ConnectAsync(
-            circuitId,
-            Clients.Caller,
-            Context.ConnectionId,
-            Context.ConnectionAborted);
-        if (circuitHost != null)
+        _ = ConnectCircuitCore(circuitId);
+
+        return;
+
+        async Task ConnectCircuitCore(CircuitId circuitId)
         {
-            _circuitHandleRegistry.SetCircuit(Context.Items, CircuitKey, circuitHost);
-            circuitHost.SetCircuitUser(Context.User);
-            circuitHost.SendPendingBatches();
-            return true;
-        }
+            // ConnectAsync will not throw.
+            var circuitHost = await _circuitRegistry.ConnectAsync(
+                circuitId,
+                Clients.Caller,
+                Context.ConnectionId,
+                Context.ConnectionAborted);
+            if (circuitHost != null)
+            {
+                _circuitHandleRegistry.SetCircuit(Context.Items, CircuitKey, circuitHost);
+                circuitHost.SetCircuitUser(Context.User);
+                circuitHost.SendPendingBatches();
+                _ = Clients.Caller.SendAsync("JS.EndConnectCircuit", true);
+                return;
+            }
 
-        // If we get here the circuit does not exist anymore. This is something that's valid for a client to
-        // recover from, and the client is not holding any resources right now other than the connection.
-        return false;
+            // If we get here the circuit does not exist anymore. This is something that's valid for a client to
+            // recover from, and the client is not holding any resources right now other than the connection.
+            _ = Clients.Caller.SendAsync("JS.EndConnectCircuit", false);
+        }
     }
 
     // This method drives the resumption of a circuit that has been previously paused and ejected out of memory.
@@ -266,10 +275,10 @@ public async ValueTask<bool> ConnectCircuit(string circuitIdSecret)
     //       * B might complete the handshake and then the circuit will resume on B.
     //     * A deletes the state before B is able to read it. Then "resumption" fails, as the circuit state is gone.
 
-    // On the server we are going to have a public method on Circuit.cs to trigger pausing a circuit from the server
-    // that returns the root components and application state as strings data-protected by the data protection provider.
-    // Those can be then passed to this method for resuming the circuit.
-    public async ValueTask<string> ResumeCircuit(
+        // On the server we are going to have a public method on Circuit.cs to trigger pausing a circuit from the server
+        // that returns the root components and application state as strings data-protected by the data protection provider.
+        // Those can be then passed to this method for resuming the circuit.
+    public async void ResumeCircuit(
         string circuitIdSecret,
         string baseUri,
         string uri,
@@ -281,7 +290,8 @@ public async ValueTask<string> ResumeCircuit(
         {
             // Invalid id.
             Log.ResumeInvalidCircuitId(_logger, circuitIdSecret);
-            return null;
+            _ = Clients.Caller.SendAsync("JS.EndResumeCircuit", (string)null, Context.ConnectionAborted);
+            return;
         }
 
         var circuitHost = _circuitHandleRegistry.GetCircuit(Context.Items, CircuitKey);
@@ -291,8 +301,9 @@ public async ValueTask<string> ResumeCircuit(
             // We can reject this and terminate the connection.
             Log.CircuitAlreadyInitialized(_logger, circuitHost.CircuitId);
             await NotifyClientError(Clients.Caller, $"The circuit host '{circuitHost.CircuitId}' has already been initialized.");
+            _ = Clients.Caller.SendAsync("JS.EndResumeCircuit", (string)null, Context.ConnectionAborted);
             Context.Abort();
-            return null;
+            return;
         }
 
         if (baseUri == null ||
@@ -307,92 +318,100 @@ public async ValueTask<string> ResumeCircuit(
             // We can reject this and terminate the connection.
             Log.InvalidInputData(_logger);
             await NotifyClientError(Clients.Caller, "The uris provided are invalid.");
+            _ = Clients.Caller.SendAsync("JS.EndResumeCircuit", (string)null, Context.ConnectionAborted);
             Context.Abort();
-            return null;
+            return;
         }
 
-        PersistedCircuitState? persistedCircuitState;
-        if (RootComponentIsEmpty(rootComponents) && string.IsNullOrEmpty(applicationState))
+        _ = ResumeCircuitCore(baseUri, uri, rootComponents, applicationState, circuitId);
+        return;
+
+        static bool RootComponentIsEmpty(string rootComponents) =>
+            string.IsNullOrEmpty(rootComponents) || rootComponents == "[]";
+
+        async Task ResumeCircuitCore(string baseUri, string uri, string rootComponents, string applicationState, CircuitId circuitId)
         {
-            persistedCircuitState = await _circuitPersistenceManager.ResumeCircuitAsync(circuitId, Context.ConnectionAborted);
-            if (persistedCircuitState == null)
+            PersistedCircuitState? persistedCircuitState;
+            if (RootComponentIsEmpty(rootComponents) && string.IsNullOrEmpty(applicationState))
             {
-                Log.InvalidInputData(_logger);
-                await NotifyClientError(Clients.Caller, "The circuit state could not be retrieved. It may have been deleted or expired.");
-                Context.Abort();
-                return null;
+                var resumeTask = _circuitPersistenceManager.ResumeCircuitAsync(circuitId, Context.ConnectionAborted);
+                persistedCircuitState = await resumeTask;
+                if (persistedCircuitState == null)
+                {
+                    Log.InvalidInputData(_logger);
+                    await NotifyClientError(Clients.Caller, "The circuit state could not be retrieved. It may have been deleted or expired.");
+                    Context.Abort();
+                    return;
+                }
             }
-        }
-        else if (!RootComponentIsEmpty(rootComponents) && !string.IsNullOrEmpty(applicationState))
-        {
-            persistedCircuitState = _circuitPersistenceManager.FromProtectedState(rootComponents, applicationState);
-            if (persistedCircuitState == null)
+            else if (!RootComponentIsEmpty(rootComponents) && !string.IsNullOrEmpty(applicationState))
+            {
+                persistedCircuitState = _circuitPersistenceManager.FromProtectedState(rootComponents, applicationState);
+                if (persistedCircuitState == null)
+                {
+                    // If we couldn't deserialize the persisted state, signal that.
+                    Log.InvalidInputData(_logger);
+                    await NotifyClientError(Clients.Caller, "The root components or application state provided are invalid.");
+                    Context.Abort();
+                    return;
+                }
+            }
+            else
             {
-                // If we couldn't deserialize the persisted state, signal that.
                 Log.InvalidInputData(_logger);
-                await NotifyClientError(Clients.Caller, "The root components or application state provided are invalid.");
+                await NotifyClientError(
+                    Clients.Caller,
+                    RootComponentIsEmpty(rootComponents) ?
+                    "The root components provided are invalid." :
+                    "The application state provided is invalid."
+                );
                 Context.Abort();
-                return null;
+                return;
             }
-        }
-        else
-        {
-            Log.InvalidInputData(_logger);
-            await NotifyClientError(
-                Clients.Caller,
-                RootComponentIsEmpty(rootComponents) ?
-                "The root components provided are invalid." :
-                "The application state provided is invalid."
-            );
-            Context.Abort();
-            return null;
-        }
 
-        try
-        {
-            var circuitClient = new CircuitClientProxy(Clients.Caller, Context.ConnectionId);
-            var resourceCollection = Context.GetHttpContext().GetEndpoint()?.Metadata.GetMetadata<ResourceAssetCollection>();
-            circuitHost = await _circuitFactory.CreateCircuitHostAsync(
-                [],
-                circuitClient,
-                baseUri,
-                uri,
-                Context.User,
-                store: null,
-                resourceCollection);
-
-            // Fire-and-forget the initialization process, because we can't block the
-            // SignalR message loop (we'd get a deadlock if any of the initialization
-            // logic relied on receiving a subsequent message from SignalR), and it will
-            // take care of its own errors anyway.
-            _ = circuitHost.InitializeAsync(store: null, _httpContext, Context.ConnectionAborted);
-
-            circuitHost.AttachPersistedState(persistedCircuitState);
-
-            // It's safe to *publish* the circuit now because nothing will be able
-            // to run inside it until after InitializeAsync completes.
-            _circuitRegistry.Register(circuitHost);
-            _circuitHandleRegistry.SetCircuit(Context.Items, CircuitKey, circuitHost);
-
-            // Returning the secret here so the client can reconnect.
-            //
-            // Logging the secret and circuit ID here so we can associate them with just logs (if TRACE level is on).
-            Log.CreatedCircuit(_logger, circuitHost.CircuitId, circuitHost.CircuitId.Secret, Context.ConnectionId);
-
-            return circuitHost.CircuitId.Secret;
-        }
-        catch (Exception ex)
-        {
-            // If the circuit fails to initialize synchronously we can notify the client immediately
-            // and shut down the connection.
-            Log.CircuitInitializationFailed(_logger, ex);
-            await NotifyClientError(Clients.Caller, "The circuit failed to initialize.");
-            Context.Abort();
-            return null;
+            try
+            {
+                var circuitClient = new CircuitClientProxy(Clients.Caller, Context.ConnectionId);
+                var resourceCollection = Context.GetHttpContext().GetEndpoint()?.Metadata.GetMetadata<ResourceAssetCollection>();
+                var circuitHost = await _circuitFactory.CreateCircuitHostAsync(
+                    [],
+                    circuitClient,
+                    baseUri,
+                    uri,
+                    Context.User,
+                    store: null,
+                    resourceCollection);
+
+                // Fire-and-forget the initialization process, because we can't block the
+                // SignalR message loop (we'd get a deadlock if any of the initialization
+                // logic relied on receiving a subsequent message from SignalR), and it will
+                // take care of its own errors anyway.
+                await circuitHost.InitializeAsync(store: null, _httpContext, Context.ConnectionAborted);
+
+                circuitHost.AttachPersistedState(persistedCircuitState);
+
+                // It's safe to *publish* the circuit now because nothing will be able
+                // to run inside it until after InitializeAsync completes.
+                _circuitRegistry.Register(circuitHost);
+                _circuitHandleRegistry.SetCircuit(Context.Items, CircuitKey, circuitHost);
+
+                // Returning the secret here so the client can reconnect.
+                //
+                // Logging the secret and circuit ID here so we can associate them with just logs (if TRACE level is on).
+                Log.CreatedCircuit(_logger, circuitHost.CircuitId, circuitHost.CircuitId.Secret, Context.ConnectionId);
+
+                await Clients.Caller.SendAsync("JS.EndResumeCircuit", circuitHost.CircuitId.Secret, Context.ConnectionAborted);
+            }
+            catch (Exception ex)
+            {
+                // If the circuit fails to initialize synchronously we can notify the client immediately
+                // and shut down the connection.
+                Log.CircuitInitializationFailed(_logger, ex);
+                await NotifyClientError(Clients.Caller, "The circuit failed to initialize.");
+                Context.Abort();
+                return;
+            }
         }
-
-        static bool RootComponentIsEmpty(string rootComponents) =>
-            string.IsNullOrEmpty(rootComponents) || rootComponents == "[]";
     }
 
     // Client initiated pauses work as follows: