VmsBlazorServerHostedService.cs

이 파일의 문서화 페이지로 가기

using Dreamine.Hybrid.Interfaces;
using Dreamine.Hybrid.State;
using DreamineVMS.Blazor.ViewModels;
using DreamineVMS.Models;
using DreamineVMS.Options;
using DreamineVMS.Services.Auth;
using DreamineVMS.Services.Cameras;
using DreamineVMS.Services.Dashboard;
using DreamineVMS.Services.Runtime;
using DreamineVMS.Services.Streaming;
using DreamineVMS.States;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Components;
using Microsoft.AspNetCore.Components.Server;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Hosting.StaticWebAssets;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.StaticFiles;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;
using System.IO;
using System.Reflection;
 
namespace DreamineVMS.Hosting;

public sealed class VmsBlazorServerHostedService<TRootComponent> : IHostedService
    where TRootComponent : IComponent
{
    private readonly IServiceProvider _rootServiceProvider;
    private readonly VmsServerOptions _options;
    private IHost? _webHost;

    public VmsBlazorServerHostedService(
        IServiceProvider rootServiceProvider,
        IOptions<VmsServerOptions> options)
    {
        _rootServiceProvider = rootServiceProvider ?? throw new ArgumentNullException(nameof(rootServiceProvider));
        _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        Assembly blazorAssembly = typeof(TRootComponent).Assembly;
 
        WebApplicationBuilder builder = WebApplication.CreateBuilder(new WebApplicationOptions
        {
            Args = Array.Empty<string>(),
            ContentRootPath = AppContext.BaseDirectory,
            ApplicationName = blazorAssembly.GetName().Name
        });
 
        StaticWebAssetsLoader.UseStaticWebAssets(builder.Environment, builder.Configuration);
 
        builder.Services
            .AddRazorComponents()
            .AddInteractiveServerComponents();
 
        builder.Services.Configure<CircuitOptions>(options =>
        {
            options.DetailedErrors = true;
        });
 
        RegisterSharedServices(builder.Services);
        RegisterBlazorViewModels(builder.Services);
 
        builder.WebHost.ConfigureKestrel(options =>
        {
            if (_options.ListenAnyIp)
            {
                options.ListenAnyIP(_options.Port);
            }
            else
            {
                options.ListenLocalhost(_options.Port);
            }
        });
 
        WebApplication app = builder.Build();
 
        FileExtensionContentTypeProvider contentTypes = CreateHlsContentTypeProvider();
 
        RemoveRangeHeadersForHls(app);
        UseHlsStaticFiles(app, contentTypes);
 
        app.UseRouting();
        app.UseAntiforgery();
 
        app.MapGet("/healthz", () => Results.Text("OK", "text/plain"));
 
        app.MapRazorComponents<TRootComponent>()
           .AddInteractiveServerRenderMode();
 
        _webHost = app;
 
        await app.StartAsync(cancellationToken).ConfigureAwait(false);
    }

    public async Task StopAsync(CancellationToken cancellationToken)
    {
        if (_webHost is null)
        {
            return;
        }
 
        try
        {
            await _webHost.StopAsync(cancellationToken).ConfigureAwait(false);
        }
        finally
        {
            _webHost.Dispose();
            _webHost = null;
        }
    }

    private void RegisterSharedServices(IServiceCollection services)
    {
        AddShared<IHybridMessageBus>(services);
        AddShared<IHybridStateStore<VmsDashboardState>>(services);
        AddShared<IVmsCameraRepository>(services);
        AddShared<ICameraRuntimeStateService>(services);
        AddShared<ICameraStreamService>(services);
        AddShared<IVmsDashboardStateService>(services);
 
    }

    private static void RegisterBlazorViewModels(IServiceCollection services)
    {
        services.AddScoped<LivePageViewModel>();
        services.AddScoped<DashboardPageViewModel>();
        services.AddScoped<VmsLocalDashboardViewModel>();
    }

    private void AddShared<TService>(IServiceCollection services)
        where TService : class
    {
        TService service = _rootServiceProvider.GetRequiredService<TService>();
        services.AddSingleton(service);
    }

    private static FileExtensionContentTypeProvider CreateHlsContentTypeProvider()
    {
        FileExtensionContentTypeProvider contentTypes = new();
 
        contentTypes.Mappings[".m3u8"] = "application/vnd.apple.mpegurl";
        contentTypes.Mappings[".ts"] = "video/mp2t";
        contentTypes.Mappings[".mp4"] = "video/mp4";
 
        return contentTypes;
    }

    private static void RemoveRangeHeadersForHls(WebApplication app)
    {
        app.Use(async (context, next) =>
        {
            PathString path = context.Request.Path;
 
            if (IsHlsPath(path))
            {
                context.Request.Headers.Remove("Range");
                context.Request.Headers.Remove("If-Range");
            }
 
            await next().ConfigureAwait(false);
        });
    }

    private static void UseHlsStaticFiles(
        WebApplication app,
        FileExtensionContentTypeProvider contentTypes)
    {
        app.UseStaticFiles(new StaticFileOptions
        {
            ContentTypeProvider = contentTypes,
            OnPrepareResponse = context =>
            {
                string extension = Path.GetExtension(context.File.PhysicalPath ?? string.Empty)
                    .ToLowerInvariant();
 
                if (extension is ".m3u8" or ".ts")
                {
                    IHeaderDictionary headers = context.Context.Response.Headers;
 
                    headers["Cache-Control"] = "no-store, must-revalidate";
                    headers["Pragma"] = "no-cache";
                    headers["Expires"] = "0";
                    headers["Accept-Ranges"] = "none";
                }
            }
        });
    }

    private static bool IsHlsPath(PathString path)
    {
        if (!path.HasValue)
        {
            return false;
        }
 
        return path.Value.EndsWith(".m3u8", StringComparison.OrdinalIgnoreCase)
            || path.Value.EndsWith(".ts", StringComparison.OrdinalIgnoreCase);
    }
}