AipGateway/AipGateway.API/Program.cs

using AipGateway.API.Services;
using Microsoft.OpenApi.Models;
using Microsoft.AspNetCore.HttpOverrides;
using System.Net;
using AutoMapper;
using AipGateway.AIP;
using AipGateway.API;
using Serilog;
using AipGateway.API.Application;
using AipGateway.API.Application.Interfaces.Services;
using AipGateway.API.Application.Mappings;
using AipGateway.API.Middlewares;
using AipGateway.API.Scheduler;
using Coravel;
using AipGateway.API.Services.Interfaces;
using AipDatabase.API.Infrastructures;
using AipGateway.API.Application.Configurations;
using Serilog.Extensions.Logging;
using AipGateway.API.Repositories;

internal class Program
{
    //private static readonly log4net.ILog _log = LogManager.GetLogger(typeof(Program));
    
    private static async Task Main(string[] args)
    {
        var configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile(
                path: "appsettings.json",
                optional: false,
                reloadOnChange: true)
            .AddJsonFile(
                path: $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json",
                optional: true,
                reloadOnChange: true)
            .Build();

        var serillogLogger = new Serilog.LoggerConfiguration()
            .ReadFrom.Configuration(configuration)
            .MinimumLevel.Information()
            .Enrich.FromLogContext()
            //.MinimumLevel.Override("Microsoft", LogEventLevel.Information)
            .CreateLogger();

        Log.Logger = serillogLogger.ForContext<Program>();

        int licenseAccounts = LicenseManager.LocalValidateLicense();
        if (licenseAccounts <= 0)
        {
            if (licenseAccounts == 0)
            {
                Log.Fatal("프로그램 라이센스에 허가된 계정 정보가 없습니다..");
            }
            else
            {
                Log.Fatal("프로그램 라이센스 정보를 확인하지 못했습니다.");
            }
            return;
        }

        try
        {
            var builder = WebApplication.CreateBuilder(args);
            builder.Logging.ClearProviders();
            builder.Host.UseSerilog((context, services, configuration) => configuration
                        .ReadFrom.Configuration(context.Configuration)
                        .ReadFrom.Services(services)
                        .Enrich.FromLogContext(), true);

            ConfigureSettings(builder.Host, builder.Environment); // 환경설정 파일 설정

            if (Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") != null)
            {
                Log.Information("Start Azure Information RESTFull API Service... License Accounts: {0} EA. [{1}]", 
                    licenseAccounts, Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT"));
            }
            else
            {
                Log.Information("Start Azure Information RESTFull API Service...License Accounts: {0} EA.", licenseAccounts);
            }

            Startup.SetSystemConfig();

            ILogger<AipDbRepository> aipDbRepositoryLogger = new SerilogLoggerFactory(serillogLogger).CreateLogger<AipDbRepository>();
            ILogger<ApiAuthService> apiAuthServiceLogger = new SerilogLoggerFactory(serillogLogger).CreateLogger<ApiAuthService>();
            ILogger<AipFileService> aipFileServiceLogger = new SerilogLoggerFactory(serillogLogger).CreateLogger<AipFileService>();

            DatabaseFactory databaseFactory = new DatabaseFactory(builder.Configuration);
            AipDbRepository aipDbRepository = new AipDbRepository(aipDbRepositoryLogger, builder.Configuration, databaseFactory);
            AipSettings aipSettings = await aipDbRepository.LoadAipConfig();

            ApiAuthService apiAuthService = new ApiAuthService(apiAuthServiceLogger, aipDbRepository);
            apiAuthService.LoadAuthInformation();

            AipFileManager aipFileManager = new AipFileManager(serillogLogger, aipSettings.GetConfig());
            if (!Startup.AipFileInitialize(aipFileManager))
            {
                Log.Error("AipFileInitialize: Failed. {0}, {1}", aipFileManager.LastErrNo, aipFileManager.LastErrMsg);
                return;
            }
            AipFileService aipFileService = new AipFileService(aipFileServiceLogger, aipDbRepository, aipFileManager, aipSettings);
            aipFileService.DownloadAipFileInformations();


            builder.Services.AddControllers();

            //FastEndpoints
            //builder.Services.AddFastEndpoints();
            builder.Services.AddSwaggerGen(c => {
                c.SwaggerDoc("v1", new OpenApiInfo { Title = "Azure Information Protection RESTFull API Service Gateway", Version = "v1" });
                //c.ResolveConflictingActions(apiDescriptions => apiDescriptions.First());
            });

            builder.Services.Configure<ForwardedHeadersOptions>(options =>
            {
                options.ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto;
                options.KnownNetworks.Clear();
                options.KnownProxies.Clear();
            });

            Log.Information("Start AIP RESTFull Service...Binding Port: {0}.", aipSettings.Port);

            //https://learn.microsoft.com/ko-kr/aspnet/core/fundamentals/servers/kestrel/options?view=aspnetcore-8.0
            builder.WebHost.ConfigureKestrel((context, serverOptions) =>
            {
                serverOptions.Limits.MaxRequestBodySize = 100_000_000;      // [RequestSizeLimit(100_000_000)] --> Controller 위에 선언,  IHttpMaxRequestBodySizeFeature
                serverOptions.Limits.MaxConcurrentConnections = 500;
                serverOptions.Limits.MaxConcurrentUpgradedConnections = 500;
                //serverOptions.Limits.Http2.InitialConnectionWindowSize = 131_072;
                serverOptions.AllowSynchronousIO = false;
                serverOptions.Listen(IPAddress.Any, aipSettings.Port, listenOptions =>
                {
                    //listenOptions.UseHttps("testCert.pfx", "testPassword");
                    //listenOptions.Protocols = HttpProtocols.Http1AndHttp2AndHttp3;
                });
            });

            builder.Services.InjectDependencies(builder.Configuration);

            builder.Services.AddSingleton<AipSettings>(aipSettings);
            builder.Services.AddSingleton<IDatabaseFactory>(databaseFactory);
            builder.Services.AddSingleton<IAipDbRepository>(aipDbRepository);
            builder.Services.AddSingleton<IApiAuthService>(apiAuthService);
            builder.Services.AddSingleton<IAipFileService>(aipFileService);

            builder.Services.AddSingleton<IAipDbLoggingService, AipDbLoggingService>();

            builder.Services.AddScoped<IApiAipService, ApiAipService>();
            builder.Services.AddScoped<IApiDbService, ApiDbService>();
            builder.Services.AddScoped<IApiFileService, ApiFileService>();
            builder.Services.AddScoped<IApiStreamService, ApiStreamService>();

            // Scheduler Job
            builder.Services.AddScheduler();
            builder.Services.AddTransient<AuthKeyLoadingInvocable>();

            var mappingConfig = new MapperConfiguration(mc =>
            {
                mc.AddProfile(new MappingProfile());
            });
            IMapper mapper = mappingConfig.CreateMapper();
            builder.Services.AddSingleton(mapper);

            builder.Services.AddHealthChecks();

            builder.Services.AddCors(p => p.AddPolicy("corsapp", builder =>
            {
                //builder.WithOrigins("*", "http://localhost:3011", "https://localhost:3011", "https://localhost:7261").AllowAnyMethod().AllowAnyHeader();
            }));

            
            var app = builder.Build();
            //app.UseExceptionHandler("/Error");
            app.UseSerilogRequestLogging();
            app.Services.UseScheduler(scheduler =>
            {
                scheduler.OnWorker("AuthKeyTasks");
                scheduler.Schedule<AuthKeyLoadingInvocable>()
                .Hourly();
            });

            //HTTP Strict Transport Security : Method used by server to declare that they should only be accessed using HTTPS (secure connection) only
            app.UseHsts();
            app.UseHttpsRedirection();

            //app.UseStaticFiles();

            app.UseRouting();
            app.UseCors(builder => builder
                .AllowAnyOrigin()
                .AllowAnyMethod()
                .AllowAnyHeader());
            app.UseCors("corsapp");

            app.UseAuthentication();
            app.UseAuthorization();

            //app.UseSerilogRequestLogging();
            app.UseMiddleware<RequestResponseLogging>();

            //app.UseHealthChecks("/health");

            //if (app.Environment.IsDevelopment())
            {
                app.UseSwagger();
                app.UseSwaggerUI(options =>
                {
                    options.SwaggerEndpoint("/swagger/v1/swagger.json", "AIP Gateway API v1");
                    options.RoutePrefix = "swagger-ui";
                });
            }

            app.MapControllers();

            app.Run();
            Log.Information("Azure Information RESTFull API Service...Stopped cleanly.");
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Azure Information RESTFull API Service...An unhandled exception occurred during bootstrapping.");
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }

    private static void ConfigureSettings(IHostBuilder hostBuilder, IHostEnvironment environment)
    {
#if false
        IConfigurationBuilder configuration = new ConfigurationBuilder()
            .SetBasePath(Directory.GetCurrentDirectory())
            .AddJsonFile(
                path: "appsettings.json",
                optional: false,
                reloadOnChange: true)
            .AddJsonFile(
                path: $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json",
                optional: true,
                reloadOnChange: true)
            .AddEnvironmentVariables();
#endif

        hostBuilder.ConfigureAppConfiguration(config =>
        {
            config
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile(
                    path: "appsettings.json",
                    optional: false,
                    reloadOnChange: true)
                .AddJsonFile(
                    path: $"appsettings.{Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT")}.json",
                    optional: true,
                    reloadOnChange: true)
                .AddEnvironmentVariables();
        });
    }


}