Revert "tmp"

This reverts commit 2edaf9e.

Author: javiercn

src/Components/Server/src/ComponentHub.cs

@@ -209,42 +209,33 @@ public async Task UpdateRootComponents(string serializedComponentOperations, str
         _ = circuitHost.UpdateRootComponents(operations, store, Context.ConnectionAborted);
     }
 
-    public void ConnectCircuit(string circuitIdSecret)
+    public async ValueTask<bool> ConnectCircuit(string circuitIdSecret)
     {
         // TryParseCircuitId will not throw.
         if (!_circuitIdFactory.TryParseCircuitId(circuitIdSecret, out var circuitId))
         {
             // Invalid id.
             Log.InvalidCircuitId(_logger, circuitIdSecret);
-            _ = Clients.Caller.SendAsync("JS.EndConnectCircuit", false);
-            return;
+            return false;
         }
 
-        _ = ConnectCircuitCore(circuitId);
-
-        return;
-
-        async Task ConnectCircuitCore(CircuitId circuitId)
+        // ConnectAsync will not throw.
+        var circuitHost = await _circuitRegistry.ConnectAsync(
+            circuitId,
+            Clients.Caller,
+            Context.ConnectionId,
+            Context.ConnectionAborted);
+        if (circuitHost != null)
         {
-            // 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.
-            _ = Clients.Caller.SendAsync("JS.EndConnectCircuit", false);
+            _circuitHandleRegistry.SetCircuit(Context.Items, CircuitKey, circuitHost);
+            circuitHost.SetCircuitUser(Context.User);
+            circuitHost.SendPendingBatches();
+            return true;
         }
+
+        // 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;
     }
 
     // This method drives the resumption of a circuit that has been previously paused and ejected out of memory.
@@ -275,10 +266,10 @@ async Task ConnectCircuitCore(CircuitId circuitId)
     //       * 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 void 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 ValueTask<string> ResumeCircuit(
         string circuitIdSecret,
         string baseUri,
         string uri,
@@ -290,8 +281,7 @@ public async void ResumeCircuit(
         {
             // Invalid id.
             Log.ResumeInvalidCircuitId(_logger, circuitIdSecret);
-            _ = Clients.Caller.SendAsync("JS.EndResumeCircuit", (string)null, Context.ConnectionAborted);
-            return;
+            return null;
         }
 
         var circuitHost = _circuitHandleRegistry.GetCircuit(Context.Items, CircuitKey);
@@ -301,9 +291,8 @@ public async void 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;
+            return null;
         }
 
         if (baseUri == null ||
@@ -318,100 +307,92 @@ public async void 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;
+            return null;
         }
 
-        _ = 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? persistedCircuitState;
+        if (RootComponentIsEmpty(rootComponents) && string.IsNullOrEmpty(applicationState))
         {
-            PersistedCircuitState? persistedCircuitState;
-            if (RootComponentIsEmpty(rootComponents) && string.IsNullOrEmpty(applicationState))
-            {
-                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)
-                {
-                    // 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
+            persistedCircuitState = await _circuitPersistenceManager.ResumeCircuitAsync(circuitId, Context.ConnectionAborted);
+            if (persistedCircuitState == null)
             {
                 Log.InvalidInputData(_logger);
-                await NotifyClientError(
-                    Clients.Caller,
-                    RootComponentIsEmpty(rootComponents) ?
-                    "The root components provided are invalid." :
-                    "The application state provided is invalid."
-                );
+                await NotifyClientError(Clients.Caller, "The circuit state could not be retrieved. It may have been deleted or expired.");
                 Context.Abort();
-                return;
+                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)
+        }
+        else if (!RootComponentIsEmpty(rootComponents) && !string.IsNullOrEmpty(applicationState))
+        {
+            persistedCircuitState = _circuitPersistenceManager.FromProtectedState(rootComponents, applicationState);
+            if (persistedCircuitState == null)
             {
-                // 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.");
+                // 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;
+                return null;
             }
         }
+        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;
+        }
+
+        static bool RootComponentIsEmpty(string rootComponents) =>
+            string.IsNullOrEmpty(rootComponents) || rootComponents == "[]";
     }
 
     // Client initiated pauses work as follows: