Blazor pages from a Plugin

[coding-red-panda]

Hello,

I've had a previous discussion here related to the IServiceProvider not loading a registered class correctly, and this was caused by DNNE and the ACL that Kestrel uses. Now I am running into what I believe to be a similar issue, and I was wondering if someone encountered this before, or has a better solution to what I am doing.

The Setup

The main application is written in C++.
We use DNNE to load C# .NET 10 ClassLibraries as plugins to that application.
Each ClassLibary has a specific entrypoint that we call (Usually our AppService) class to "start".

One of these plugins starts a Kestrel webserver and is supposed to server Blazor pages.

The Issue

The out of the box setup for Kestrel manages to load the MudBlazor components and pages, but static assets such as the CSS and JS files from both MudBlazor and Blazor itself are not loaded/served by Kestrel.

The Workaround

I need to do the following to make this all work:

namespace My.PlugIn.PluginName
{
    public class AppService : ServiceWithSettings
    {
        public override void StartService()
        {
            _logger.LogInformation("Starting SiteGateway Configuration Service...");
            _cts = new CancellationTokenSource();

            // get the data path from the DataStore.
            var dataStore = DataStore.ExecuteInTx(tx => tx.GetKeySubtree("services.Platform"));
            var dataPath = dataStore["services.Platform.dataPath"];
            
            // Create and configure the Kestrel webserver.
            // This will also act as our main dependency injection container for the plugin.
            _webHost = Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    var pluginPath = Path.GetDirectoryName(typeof(AppService).Assembly.Location)!;
                    
                    webBuilder
                        // Set the content root to the base directory of the plugin. wwwroot will be next to it.
                        .UseContentRoot(pluginPath)
                        .UseWebRoot(Path.Combine(pluginPath, "wwwroot"))
                        // Configure logging for the Kestrel webserver.
                        .ConfigureLogging(logging =>
                        {
                            logging.ClearProviders();
                            logging.AddConsole();
                            logging.AddPlatformLogger(PluginAPI.Log);
                            logging.SetMinimumLevel(LogLevel.Debug);
                        })
                        // Configure the services for our plugin
                        .ConfigureServices((_, services) =>
                        {
                            ConfigureContainer(services, dataPath.ToObject<string>()!);
                            _logger.LogInformation("SiteGateway Configuration Plugin Services configured");
                        })
                        // Configure the Kestrel webserver itself.
                        .Configure(ConfigureKestrelApplication)
                        // Configure the Kestrel webserver behavior
                        .ConfigureKestrel((_, options) =>
                        {
                            var myQOptions = options
                                .ApplicationServices
                                .GetRequiredService<IOptionsMonitor<MyQServerOptions>>()
                                .Get(MyQOptions.SiteGateway);

                            // Register Kestrel to listen on the configured port.
                            // This uses only HTTP traffic, but this is internal communication only.
                            options.ListenLocalhost(myQOptions.ClientPort);

                            _logger.LogInformation("SiteGateway Configuration Plugin Kestrel configured");
                        });
                })
                .Build();

            // Start the web host in the background
            try
            {
                _logger.LogInformation("SiteGateway Configuration Plugin Kestrel Started");
                _webHost.Start();
            }
            catch (OperationCanceledException)
            {
                _logger.LogInformation("Kestrel webserver was cancelled.");
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Kestrel encountered an error");
            }

            base.StartService();
        }

        private void ConfigureContainer(IServiceCollection serviceCollection, string dataPath)
        {
            serviceCollection
                // Register all services here
                // Register the controllers in Kestrel so they can be mapped.
                .AddControllers()
                // Wipe out the Assembly Registration and do it manually
                .ConfigureApplicationPartManager(apm =>
                {
                    // Clear any parts that ASP.NET Core registers on its own.
                    // This prevents the "Default ACL" from seeing your controllers.
                    apm.ApplicationParts.Clear();
                    
                    // Add the assembly from the current (Isolated) context.
                    var assembly = typeof(AppService).Assembly;
                    apm.ApplicationParts.Add(new AssemblyPart(assembly));
                })
                // Register Newtonsoft JSON support as the default provider.
                .AddNewtonsoftJson(options =>
                {
                    // Optional but commonly needed
                    options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
                    options.SerializerSettings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
                });

            // Register Blazor and MudBlazor
            serviceCollection.AddServerSideBlazor();
            serviceCollection
                .AddRazorComponents()
                .AddInteractiveServerComponents();
            serviceCollection.AddMudServices();
        }

        private static void ConfigureKestrelApplication(IApplicationBuilder app)
        {
            // Add a developer exception page for detailed errors (local debugging only)
            app.UseDeveloperExceptionPage();

            // Enable Static files middleware for Blazor
            app.UseStaticFiles();
            
            // Serve _framework files from the plugin directory
            var pluginPath = Path.GetDirectoryName(typeof(AppService).Assembly.Location)!;
            var frameworkPath = Path.Combine(pluginPath, "_framework");
    
            if (Directory.Exists(frameworkPath))
            {
                app.UseStaticFiles(new StaticFileOptions
                {
                    FileProvider = new PhysicalFileProvider(frameworkPath),
                    RequestPath = "/_framework"
                });
            }
            
            // Add the standard middlewares
            app.UseRouting();
            app.UseAntiforgery();

            app.UseEndpoints(endpoints =>
            {
                // Add our Blazor pages
                endpoints.MapRazorComponents<App>()
                    .AddInteractiveServerRenderMode();
                
                // Add our controllers
                endpoints.MapControllers();

                // Add the Blazor Hub endpoint for server interactivity
                endpoints.MapBlazorHub();
            });
        }
    }
}

The above allows me to actually work with MudBlazor, but it still fails to load the core Blazor functionality such as blazor.web.js
To make the latter work, I need to manually copy the assets after the build to include them in our package installer:

<Target Name="PostBuild" AfterTargets="PostBuildEvent">
        <PropertyGroup>
            <SharedFolder>$(ProjectDir)..\bin\$(Configuration)\shared.net</SharedFolder>
            <OutputFolder>$(ProjectDir)..\bin\$(Configuration)</OutputFolder>
        </PropertyGroup>

        <Exec Command="dotnet publish &quot;$(ProjectPath)&quot; -o &quot;$(SharedFolder)&quot; -c $(Configuration) --no-build" />

        <ItemGroup>
            <DeleteFiles Include="$(SharedFolder)\*.deps.json;$(SharedFolder)\*.lib;$(SharedFolder)\*.h" />
        </ItemGroup>
        <Delete Files="@(DeleteFiles)" />
        <ItemGroup>
            <TargetFiles Include="$(SharedFolder)\$(TargetName).*;$(SharedFolder)\$(DnneNativeBinaryName).*" />
        </ItemGroup>
        <Move SourceFiles="@(TargetFiles)" DestinationFolder="$(SharedFolder)\.." />

        <!-- Copy wwwroot folder -->
        <ItemGroup>
            <WwwRootFiles Include="$(SharedFolder)\wwwroot\**\*.*" />
        </ItemGroup>
        <Copy SourceFiles="@(WwwRootFiles)"
              DestinationFiles="@(WwwRootFiles->'$(ProjectDir)..\bin\$(Configuration)\wwwroot\%(RecursiveDir)%(Filename)%(Extension)')"
              SkipUnchangedFiles="true" />

        <!-- Find and copy blazor.web.js from NuGet packages -->
        <ItemGroup>
            <BlazorWebJsFiles Include="$(NuGetPackageRoot)**\blazor.web.js" />
        </ItemGroup>
        <MakeDir Directories="$(OutputFolder)\_framework" />
        <Copy SourceFiles="@(BlazorWebJsFiles)"
              DestinationFolder="$(OutputFolder)\_framework"
              Condition="'@(BlazorWebJsFiles)' != ''" />

        <Copy SourceFiles="..\..\plugin-common-cs\Plugin.runtimeconfig.json" DestinationFiles="$(ProjectDir)..\bin\$(Configuration)\$(TargetName).runtimeconfig.json" UseHardlinksIfPossible="true" />
    </Target>

The above copies the output files to a shared folder, including all DLL dependencies etc.
I need to manually extract and copy the Blazor web JS file, otherwise Kestrel returns 404.

Can...someone explain why I need to do it this way, and Kestrel can't serve blazor.web.js directly?
Isn't this file supposed to be a core thing of the Blazor package?