Fix: dotnet#6882 - Explode UseBlazor (dotnet#9449)

This changes the recipe for client-side blazor to use similar primitives
to server side applications.

---

I ignored auto-rebuild support because it's currently dead code until we
have that in VS. If we add auto-rebuild to ASP.NET Core - we'd probably want
to make that a separate gesture inside `IsDevelopement()` like other
dev-time features anyway.

---

The static files hookup is a special thing because creating the file
server for a client-side Blazor app involves some non-trivial work. We
plan to make this better in the future.

What's nice about this pattern is that the implementation is pretty
simple and literal, and it scales fine if you have multiple Blazor
client-side apps.

I didn't provide a lot of options here, it's pretty much the same as
UseBlazor.

---

I feel pretty good about the wireup with routing to use the
`index.html` from the client app. I think it's pretty to-the-point.

Author: rynowak

src/Components/Blazor/DevServer/src/Server/Startup.cs

@@ -20,6 +20,7 @@ internal class Startup
         public void ConfigureServices(IServiceCollection services)
         {
             services.AddRouting();
+
             services.AddResponseCompression(options =>
             {
                 options.MimeTypes = ResponseCompressionDefaults.MimeTypes.Concat(new[]
@@ -30,15 +31,22 @@ public void ConfigureServices(IServiceCollection services)
             });
         }
 
-        public void Configure(IApplicationBuilder app, IConfiguration configuration)
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment environment, IConfiguration configuration)
         {
             app.UseDeveloperExceptionPage();
             app.UseResponseCompression();
             EnableConfiguredPathbase(app, configuration);
 
-            var clientAssemblyPath = FindClientAssemblyPath(app);
-            app.UseBlazor(new BlazorOptions { ClientAssemblyPath = clientAssemblyPath });
             app.UseBlazorDebugging();
+
+            app.UseClientSideBlazorFiles(FindClientAssemblyPath(environment));
+
+            app.UseRouting();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapFallbackToClientSideBlazor(FindClientAssemblyPath(environment), "index.html");
+            });
         }
 
         private static void EnableConfiguredPathbase(IApplicationBuilder app, IConfiguration configuration)
@@ -66,10 +74,9 @@ private static void EnableConfiguredPathbase(IApplicationBuilder app, IConfigura
             }
         }
 
-        private static string FindClientAssemblyPath(IApplicationBuilder app)
+        private static string FindClientAssemblyPath(IWebHostEnvironment environment)
         {
-            var env = app.ApplicationServices.GetRequiredService<IWebHostEnvironment>();
-            var contentRoot = env.ContentRootPath;
+            var contentRoot = environment.ContentRootPath;
             var binDir = FindClientBinDir(contentRoot);
             var appName = Path.GetFileName(contentRoot); // TODO: Allow for the possibility that the assembly name has been overridden
             var assemblyPath = Path.Combine(binDir, $"{appName}.dll");

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

@@ -3,18 +3,20 @@
 
 namespace Microsoft.AspNetCore.Builder
 {
-    public static partial class BlazorApplicationBuilderExtensions
+    public static partial class BlazorHostingApplicationBuilderExtensions
     {
-        public static Microsoft.AspNetCore.Builder.IApplicationBuilder UseBlazor(this Microsoft.AspNetCore.Builder.IApplicationBuilder app, Microsoft.AspNetCore.Builder.BlazorOptions options) { throw null; }
-        public static Microsoft.AspNetCore.Builder.IApplicationBuilder UseBlazor<TProgram>(this Microsoft.AspNetCore.Builder.IApplicationBuilder app) { throw null; }
+        public static Microsoft.AspNetCore.Builder.IApplicationBuilder UseClientSideBlazorFiles(this Microsoft.AspNetCore.Builder.IApplicationBuilder app, string clientAssemblyFilePath) { throw null; }
+        public static Microsoft.AspNetCore.Builder.IApplicationBuilder UseClientSideBlazorFiles<TClientApp>(this Microsoft.AspNetCore.Builder.IApplicationBuilder app) { throw null; }
     }
-    public static partial class BlazorMonoDebugProxyAppBuilderExtensions
+    public static partial class BlazorHostingEndpointRouteBuilderExtensions
     {
-        public static void UseBlazorDebugging(this Microsoft.AspNetCore.Builder.IApplicationBuilder app) { }
+        public static Microsoft.AspNetCore.Builder.IEndpointConventionBuilder MapFallbackToClientSideBlazor(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, string clientAssemblyFilePath, string filePath) { throw null; }
+        public static Microsoft.AspNetCore.Builder.IEndpointConventionBuilder MapFallbackToClientSideBlazor(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, string clientAssemblyFilePath, string pattern, string filePath) { throw null; }
+        public static Microsoft.AspNetCore.Builder.IEndpointConventionBuilder MapFallbackToClientSideBlazor<TClientApp>(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, string filePath) { throw null; }
+        public static Microsoft.AspNetCore.Builder.IEndpointConventionBuilder MapFallbackToClientSideBlazor<TClientApp>(this Microsoft.AspNetCore.Routing.IEndpointRouteBuilder endpoints, string pattern, string filePath) { throw null; }
     }
-    public partial class BlazorOptions
+    public static partial class BlazorMonoDebugProxyAppBuilderExtensions
     {
-        public BlazorOptions() { }
-        public string ClientAssemblyPath { [System.Runtime.CompilerServices.CompilerGeneratedAttribute]get { throw null; } [System.Runtime.CompilerServices.CompilerGeneratedAttribute]set { } }
+        public static void UseBlazorDebugging(this Microsoft.AspNetCore.Builder.IApplicationBuilder app) { }
     }
 }

src/Components/Blazor/Server/src/BlazorConfig.cs

@@ -47,5 +47,32 @@ private BlazorConfig(string assemblyPath)
             EnableAutoRebuilding = configLines.Contains("autorebuild:true", StringComparer.Ordinal);
             EnableDebugging = configLines.Contains("debug:true", StringComparer.Ordinal);
         }
+
+        public string FindIndexHtmlFile()
+        {
+            // Before publishing, the client project may have a wwwroot directory.
+            // If so, and if it contains index.html, use that.
+            if (!string.IsNullOrEmpty(WebRootPath))
+            {
+                var wwwrootIndexHtmlPath = Path.Combine(WebRootPath, "index.html");
+                if (File.Exists(wwwrootIndexHtmlPath))
+                {
+                    return wwwrootIndexHtmlPath;
+                }
+            }
+
+            // After publishing, the client project won't have a wwwroot directory.
+            // The contents from that dir will have been copied to "dist" during publish.
+            // So if "dist/index.html" now exists, use that.
+            var distIndexHtmlPath = Path.Combine(DistPath, "index.html");
+            if (File.Exists(distIndexHtmlPath))
+            {
+                return distIndexHtmlPath;
+            }
+
+            // Since there's no index.html, we'll use the default DefaultPageStaticFileOptions,
+            // hence we'll look for index.html in the host server app's wwwroot.
+            return null;
+        }
     }
 }

src/Components/Blazor/Server/src/Builder/BlazorApplicationBuilderExtensions.cs

@@ -0,0 +1,98 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// 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 System.Net.Mime;
+using Microsoft.AspNetCore.Blazor.Server;
+using Microsoft.AspNetCore.StaticFiles;
+using Microsoft.Extensions.FileProviders;
+
+namespace Microsoft.AspNetCore.Builder
+{
+    /// <summary>
+    /// Provides extension methods for hosting client-side Blazor applications in ASP.NET Core.
+    /// </summary>
+    public static class BlazorHostingApplicationBuilderExtensions
+    {
+        /// <summary>
+        /// Adds a <see cref="StaticFileMiddleware"/> that will serve static files from the client-side Blazor application
+        /// specified by <typeparamref name="TClientApp"/>.
+        /// </summary>
+        /// <typeparam name="TClientApp">A type in the client-side application.</typeparam>
+        /// <param name="app">The <see cref="IApplicationBuilder"/>.</param>
+        /// <returns>The <see cref="IApplicationBuilder"/>.</returns>
+        public static IApplicationBuilder UseClientSideBlazorFiles<TClientApp>(this IApplicationBuilder app)
+        {
+            if (app == null)
+            {
+                throw new ArgumentNullException(nameof(app));
+            }
+
+            UseClientSideBlazorFiles(app, typeof(TClientApp).Assembly.Location);
+            return app;
+        }
+
+        /// <summary>
+        /// Adds a <see cref="StaticFileMiddleware"/> that will serve static files from the client-side Blazor application
+        /// specified by <paramref name="clientAssemblyFilePath"/>.
+        /// </summary>
+        /// <param name="clientAssemblyFilePath">The file path of the client-side Blazor application assembly.</param>
+        /// <param name="app">The <see cref="IApplicationBuilder"/>.</param>
+        /// <returns>The <see cref="IApplicationBuilder"/>.</returns>
+        public static IApplicationBuilder UseClientSideBlazorFiles(this IApplicationBuilder app, string clientAssemblyFilePath)
+        {
+            if (clientAssemblyFilePath == null)
+            {
+                throw new ArgumentNullException(nameof(clientAssemblyFilePath));
+            }
+
+            var fileProviders = new List<IFileProvider>();
+
+            // TODO: Make the .blazor.config file contents sane
+            // Currently the items in it are bizarre and don't relate to their purpose,
+            // hence all the path manipulation here. We shouldn't be hardcoding 'dist' here either.
+            var config = BlazorConfig.Read(clientAssemblyFilePath);
+
+            // First, match the request against files in the client app dist directory
+            fileProviders.Add(new PhysicalFileProvider(config.DistPath));
+
+            // * Before publishing, we serve the wwwroot files directly from source
+            //   (and don't require them to be copied into dist).
+            //   In this case, WebRootPath will be nonempty if that directory exists.
+            // * After publishing, the wwwroot files are already copied to 'dist' and
+            //   will be served by the above middleware, so we do nothing here.
+            //   In this case, WebRootPath will be empty (the publish process sets this).
+            if (!string.IsNullOrEmpty(config.WebRootPath))
+            {
+                fileProviders.Add(new PhysicalFileProvider(config.WebRootPath));
+            }
+
+            // We can't modify an IFileContentTypeProvider, so we have to decorate.
+            var contentTypeProvider = new FileExtensionContentTypeProvider();
+            AddMapping(contentTypeProvider, ".dll", MediaTypeNames.Application.Octet);
+            if (config.EnableDebugging)
+            {
+                AddMapping(contentTypeProvider, ".pdb", MediaTypeNames.Application.Octet);
+            }
+
+            var options = new StaticFileOptions()
+            {
+                ContentTypeProvider = contentTypeProvider,
+                FileProvider = new CompositeFileProvider(fileProviders),
+                OnPrepareResponse = CacheHeaderSettings.SetCacheHeaders,
+            };
+
+            app.UseStaticFiles(options);
+            return app;
+
+            static void AddMapping(FileExtensionContentTypeProvider provider, string name, string mimeType)
+            {
+                if (!provider.Mappings.ContainsKey(name))
+                {
+                    provider.Mappings.Add(name, mimeType);
+                }
+            }
+        }
+    }
+}