Javiercn/blazor improved circuit is

eng/Dependencies.props

@@ -41,6 +41,7 @@ and are generated based on the last package release.
     <LatestPackageReference Include="Microsoft.AspNetCore.Razor.Language" Version="$(MicrosoftAspNetCoreRazorLanguagePackageVersion)" />
     <LatestPackageReference Include="Microsoft.AspNetCore.Testing" Version="$(MicrosoftAspNetCoreTestingPackageVersion)" />
     <LatestPackageReference Include="Microsoft.Azure.KeyVault" Version="$(MicrosoftAzureKeyVaultPackageVersion)" />
+    <LatestPackageReference Include="Microsoft.Azure.SignalR" Version="1.1.0-preview1-10426" />
     <LatestPackageReference Include="Microsoft.Azure.Storage.Blob" Version="$(MicrosoftAzureStorageBlobPackageVersion)" />
     <LatestPackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="$(MicrosoftBclAsyncInterfacesPackageVersion)" />
     <LatestPackageReference Include="Microsoft.Build.Framework" Version="$(MicrosoftBuildFrameworkPackageVersion)" />

src/Components/Browser.JS/src/Boot.Server.ts

@@ -14,6 +14,7 @@ import { discoverPrerenderedCircuits, startCircuit } from './Platform/Circuits/C
 type SignalRBuilder = (builder: signalR.HubConnectionBuilder) => void;
 interface BlazorOptions {
   configureSignalR: SignalRBuilder;
+  serviceUrl: string;
   logLevel: LogLevel;
 }
 
@@ -29,6 +30,7 @@ async function boot(userOptions?: Partial<BlazorOptions>): Promise<void> {
 
   const defaultOptions: BlazorOptions = {
     configureSignalR: (_) => { },
+    serviceUrl: '_blazor',
     logLevel: LogLevel.Warning,
   };
 
@@ -51,9 +53,15 @@ async function boot(userOptions?: Partial<BlazorOptions>): Promise<void> {
   });
 
   // pass options.configureSignalR to configure the signalR.HubConnectionBuilder
-  const initialConnection = await initializeConnection(options, circuitHandlers, logger);
-
   const circuits = discoverPrerenderedCircuits(document);
+  if (circuits.length > 1){
+    throw new Error('Can\'t have multiple circuits per connection');
+  }
+
+  const circuitId = circuits.length > 0 ? circuits[0].circuitId : await getNewCircuitId(options);
+
+  const initialConnection = await initializeConnection(options, circuitHandlers, circuitId, logger);
+
   for (let i = 0; i < circuits.length; i++) {
     const circuit = circuits[i];
     for (let j = 0; j < circuit.components.length; j++) {
@@ -65,18 +73,12 @@ async function boot(userOptions?: Partial<BlazorOptions>): Promise<void> {
   // Ensure any embedded resources have been loaded before starting the app
   await embeddedResourcesPromise;
 
-  const circuit = await startCircuit(initialConnection);
-
-  if (!circuit) {
-    logger.log(LogLevel.Information, 'No preregistered components to render.');
-  }
-
   const reconnect = async (existingConnection?: signalR.HubConnection): Promise<boolean> => {
     if (renderingFailed) {
       // We can't reconnect after a failure, so exit early.
       return false;
     }
-    const reconnection = existingConnection || await initializeConnection(options, circuitHandlers, logger);
+    const reconnection = existingConnection || await initializeConnection(options, circuitHandlers, circuitId, logger);
     const results = await Promise.all(circuits.map(circuit => circuit.reconnect(reconnection)));
 
     if (reconnectionFailed(results)) {
@@ -89,13 +91,15 @@ async function boot(userOptions?: Partial<BlazorOptions>): Promise<void> {
 
   window['Blazor'].reconnect = reconnect;
 
-  const reconnectTask = reconnect(initialConnection);
+  await reconnect(initialConnection);
 
-  if (circuit) {
-    circuits.push(circuit);
-  }
+  // We render any additional component after all prerendered components have
+  // re-stablished the connection with the circuit.
+  const renderedComponents = await startCircuit(circuitId, initialConnection);
 
-  await reconnectTask;
+  if (!renderedComponents) {
+    logger.log(LogLevel.Information, 'No preregistered components to render.');
+  }
 
   logger.log(LogLevel.Information, 'Blazor server-side application started.');
 
@@ -104,13 +108,23 @@ async function boot(userOptions?: Partial<BlazorOptions>): Promise<void> {
   }
 }
 
-async function initializeConnection(options: Required<BlazorOptions>, circuitHandlers: CircuitHandler[], logger: ILogger): Promise<signalR.HubConnection> {
+async function getNewCircuitId(options: BlazorOptions): Promise<string> {
+  const response = await fetch(`${options.serviceUrl}/start`, {
+    method: 'POST',
+  });
+
+  const responseBody = await response.json() as { id: string };
+
+  return responseBody.id;
+}
+
+async function initializeConnection(options: Required<BlazorOptions>, circuitHandlers: CircuitHandler[], circuitId: string, logger: ILogger): Promise<signalR.HubConnection> {
 
   const hubProtocol = new MessagePackHubProtocol();
   (hubProtocol as unknown as { name: string }).name = 'blazorpack';
 
   const connectionBuilder = new signalR.HubConnectionBuilder()
-    .withUrl('_blazor')
+    .withUrl(`${options.serviceUrl}?circuitId=${circuitId}`)
     .withHubProtocol(hubProtocol);
 
   options.configureSignalR(connectionBuilder);

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

@@ -37,8 +37,8 @@ export function discoverPrerenderedCircuits(document: Document): CircuitDescript
   return circuits;
 }
 
-export async function startCircuit(connection: signalR.HubConnection): Promise<CircuitDescriptor | undefined> {
-  const result = await connection.invoke<string>('StartCircuit', uriHelperFunctions.getLocationHref(), uriHelperFunctions.getBaseURI());
+export async function startCircuit(circuitId: string, connection: signalR.HubConnection): Promise<CircuitDescriptor | undefined> {
+  const result = await connection.invoke<string>('StartCircuit', circuitId, uriHelperFunctions.getLocationHref(), uriHelperFunctions.getBaseURI());
   if (result) {
     return new CircuitDescriptor(result, []);
   } else {

src/Components/Server/ref/Microsoft.AspNetCore.Components.Server.csproj

@@ -5,6 +5,8 @@
   </PropertyGroup>
   <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.0'">
     <Compile Include="Microsoft.AspNetCore.Components.Server.netcoreapp3.0.cs" />
+    <Reference Include="Microsoft.AspNetCore.Authentication"  />
+    <Reference Include="Microsoft.AspNetCore.Cors"  />
     <Reference Include="Microsoft.AspNetCore.Components.Browser"  />
     <Reference Include="Microsoft.AspNetCore.DataProtection"  />
     <Reference Include="Microsoft.Extensions.Logging"  />

src/Components/Server/ref/Microsoft.AspNetCore.Components.Server.netcoreapp3.0.cs

@@ -11,6 +11,8 @@ public static partial class ComponentEndpointRouteBuilderExtensions
     {
         public static Microsoft.AspNetCore.Components.Server.ComponentEndpointConventionBuilder MapBlazorHub(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints) { throw null; }
         public static Microsoft.AspNetCore.Components.Server.ComponentEndpointConventionBuilder MapBlazorHub(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, System.Action<Microsoft.AspNetCore.Http.Connections.HttpConnectionDispatcherOptions> configureOptions) { throw null; }
+        public static Microsoft.AspNetCore.Components.Server.ComponentEndpointConventionBuilder MapBlazorHub(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, string path) { throw null; }
+        public static Microsoft.AspNetCore.Components.Server.ComponentEndpointConventionBuilder MapBlazorHub(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, string path, System.Action<Microsoft.AspNetCore.Http.Connections.HttpConnectionDispatcherOptions> configureOptions) { throw null; }
         public static Microsoft.AspNetCore.Components.Server.ComponentEndpointConventionBuilder MapBlazorHub(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, System.Type type, string selector) { throw null; }
         public static Microsoft.AspNetCore.Components.Server.ComponentEndpointConventionBuilder MapBlazorHub(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, System.Type type, string selector, System.Action<Microsoft.AspNetCore.Http.Connections.HttpConnectionDispatcherOptions> configureOptions) { throw null; }
         public static Microsoft.AspNetCore.Components.Server.ComponentEndpointConventionBuilder MapBlazorHub(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, System.Type componentType, string selector, string path) { throw null; }

src/Components/Server/src/Builder/ComponentEndpointConventionBuilder.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.SignalR;
 
@@ -12,11 +13,11 @@ namespace Microsoft.AspNetCore.Components.Server
     /// </summary>
     public sealed class ComponentEndpointConventionBuilder : IHubEndpointConventionBuilder
     {
-        private readonly IEndpointConventionBuilder _endpointConventionBuilder;
+        private readonly IEndpointConventionBuilder[] _endpointConventionBuilders;
 
-        internal ComponentEndpointConventionBuilder(IEndpointConventionBuilder endpointConventionBuilder)
+        internal ComponentEndpointConventionBuilder(params IEndpointConventionBuilder[] endpointConventionBuilders)
         {
-            _endpointConventionBuilder = endpointConventionBuilder;
+            _endpointConventionBuilders = endpointConventionBuilders;
         }
 
         /// <summary>
@@ -25,7 +26,10 @@ internal ComponentEndpointConventionBuilder(IEndpointConventionBuilder endpointC
         /// <param name="convention">The convention to add to the builder.</param>
         public void Add(Action<EndpointBuilder> convention)
         {
-            _endpointConventionBuilder.Add(convention);
+            for (int i = 0; i < _endpointConventionBuilders.Length; i++)
+            {
+                _endpointConventionBuilders[i].Add(convention);
+            }
         }
     }
 }

src/Components/Server/src/Builder/ComponentEndpointRouteBuilderExtensions.cs

@@ -4,6 +4,7 @@
 using System;
 using Microsoft.AspNetCore.Components;
 using Microsoft.AspNetCore.Components.Server;
+using Microsoft.AspNetCore.Cors;
 using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.AspNetCore.Routing;
 using Microsoft.AspNetCore.SignalR;
@@ -30,6 +31,22 @@ public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRout
             return endpoints.MapBlazorHub(configureOptions: _ => { });
         }
 
+        /// <summary>
+        /// Maps the Blazor <see cref="Hub" /> to the path <paramref name="path"/>.
+        /// </summary>
+        /// <param name="endpoints">The <see cref="IEndpointRouteBuilder"/>.</param>
+        /// <param name="path">The path to map the Blazor <see cref="Hub" />.</param>
+        /// <returns>The <see cref="ComponentEndpointConventionBuilder"/>.</returns>
+        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, string path)
+        {
+            if (endpoints == null)
+            {
+                throw new ArgumentNullException(nameof(endpoints));
+            }
+
+            return endpoints.MapBlazorHub(path, configureOptions: _ => { });
+        }
+
         /// <summary>
         /// Maps the Blazor <see cref="Hub" /> to the default path.
         /// </summary>
@@ -48,7 +65,31 @@ public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRout
                 throw new ArgumentNullException(nameof(configureOptions));
             }
 
-            return new ComponentEndpointConventionBuilder(endpoints.MapHub<ComponentHub>(ComponentHub.DefaultPath, configureOptions));
+            return endpoints.MapBlazorHub(ComponentHub.DefaultPath, configureOptions);
+        }
+
+        /// <summary>
+        /// Maps the Blazor <see cref="Hub" /> to the path <paramref name="path"/>.
+        /// </summary>
+        /// <param name="endpoints">The <see cref="IEndpointRouteBuilder"/>.</param>
+        /// <param name="path">The path to map the Blazor <see cref="Hub" />.</param>
+        /// <param name="configureOptions">A callback to configure dispatcher options.</param>
+        /// <returns>The <see cref="ComponentEndpointConventionBuilder"/>.</returns>
+        public static ComponentEndpointConventionBuilder MapBlazorHub(this IEndpointRouteBuilder endpoints, string path, Action<HttpConnectionDispatcherOptions> configureOptions)
+        {
+            if (endpoints == null)
+            {
+                throw new ArgumentNullException(nameof(endpoints));
+            }
+
+            if (configureOptions == null)
+            {
+                throw new ArgumentNullException(nameof(configureOptions));
+            }
+
+            return new ComponentEndpointConventionBuilder(
+                endpoints.MapHub<ComponentHub>(path, configureOptions),
+                endpoints.MapStartCircuitEndpoint(path + "/start"));
         }
 
         /// <summary>
@@ -328,7 +369,8 @@ public static ComponentEndpointConventionBuilder MapBlazorHub(
                 throw new ArgumentNullException(nameof(configureOptions));
             }
 
-            return new ComponentEndpointConventionBuilder(endpoints.MapHub<ComponentHub>(path, configureOptions)).AddComponent(componentType, selector);
+            return endpoints.MapBlazorHub(path, configureOptions)
+                .AddComponent(componentType, selector);
         }
     }
 }

src/Components/Server/src/CircuitOptions.cs

@@ -2,6 +2,7 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.DataProtection;
 
 namespace Microsoft.AspNetCore.Components.Server

src/Components/Server/src/Circuits/Circuit.cs

@@ -18,6 +18,6 @@ internal Circuit(CircuitHost circuitHost)
         /// <summary>
         /// Gets the identifier for the <see cref="Circuit"/>.
         /// </summary>
-        public string Id => _circuitHost.CircuitId;
+        public string Id => _circuitHost.CircuitId.RequestToken;
     }
 }

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

@@ -50,7 +50,7 @@ public static void SetCurrentCircuitHost(CircuitHost circuitHost)
         public event UnhandledExceptionEventHandler UnhandledException;
 
         public CircuitHost(
-            string circuitId,
+            CircuitId circuitId,
             IServiceScope scope,
             CircuitClientProxy client,
             RendererRegistry rendererRegistry,
@@ -80,7 +80,7 @@ public CircuitHost(
             Renderer.UnhandledSynchronizationException += SynchronizationContext_UnhandledException;
         }
 
-        public string CircuitId { get; }
+        public CircuitId CircuitId { get; }
 
         public Circuit Circuit { get; }
 
@@ -140,7 +140,7 @@ internal void SendPendingBatches()
             var _ = Renderer.InvokeAsync(() => Renderer.ProcessBufferedRenderBatches());
         }
 
-        public async Task InitializeAsync(CancellationToken cancellationToken)
+        public async Task InitializeAsync(CancellationToken cancellationToken, bool existingCircuit)
         {
             await Renderer.InvokeAsync(async () =>
             {
@@ -149,8 +149,15 @@ await Renderer.InvokeAsync(async () =>
                     SetCurrentCircuitHost(this);
                     _initialized = true; // We're ready to accept incoming JSInterop calls from here on
 
-                    await OnCircuitOpenedAsync(cancellationToken);
-                    await OnConnectionUpAsync(cancellationToken);
+                    if (!existingCircuit)
+                    {
+                        // If the circuit we are using was created during prerendering don't run
+                        // the lifecycle events again at this time.
+                        // Circuit opened ran during prerendering
+                        // ConnectionUp will run after the reconnection is completed.
+                        await OnCircuitOpenedAsync(cancellationToken);
+                        await OnConnectionUpAsync(cancellationToken);
+                    }
 
                     // We add the root components *after* the circuit is flagged as open.
                     // That's because AddComponentAsync waits for quiescence, which can take
@@ -289,7 +296,7 @@ private async Task OnCircuitDownAsync()
 
         public async ValueTask DisposeAsync()
         {
-            Log.DisposingCircuit(_logger, CircuitId);
+            Log.DisposingCircuit(_logger, CircuitId.RequestToken);
 
             await Renderer.InvokeAsync(async () =>
             {