GBase/GBase.Server/Program.cs

// Author: Gockner, Simon
// Created: 2020-02-07
// Copyright(c) 2020 SimonG. All Rights Reserved.

using System;
using System.Threading.Tasks;
using CoreWCF.Configuration;
using GBase.Api.Communication;
using GBase.Logging.Factories;
using GBase.Logging.Interfaces;
using GBase.Server.Factories;
using GBase.Server.Interfaces;
using LightweightIocContainer.Interfaces;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;

namespace GBase.Server
{
    class Program
    {
        static async Task Main(string[] args)
        {
            Bootstrapper bootstrapper = new Bootstrapper();
            IIocContainer kernel = bootstrapper.BootstrapContainer();

            ILogFactory logFactory = kernel.Resolve<ILogFactory>();
            ILog log = logFactory.Create();
            log.InitializeLog();

            IConsoleLoggerFactory consoleLoggerFactory = kernel.Resolve<IConsoleLoggerFactory>();
            log.AddLogger(consoleLoggerFactory.Create());

            try
            {
                IGBaseServerSettingsFactory gBaseServerSettingsFactory = kernel.Resolve<IGBaseServerSettingsFactory>();
                IGBaseServerSettings serverSettings = gBaseServerSettingsFactory.Create();
                await serverSettings.ParseArguments(args);

                IFileLoggerFactory fileLoggerFactory = kernel.Resolve<IFileLoggerFactory>();
                log.AddLogger(fileLoggerFactory.Create(serverSettings.LogFilePath, serverSettings.LogFileName));

                IWebHost host = CreateWebHostBuilder(serverSettings).Build();
                await host.RunAsync();

                host.Dispose(); //TestMe: Check if this destroys the server while it is running
            }
            catch (Exception ex) //TODO: decide what to do in this case
            {
                Console.WriteLine(ex);
                throw;
            }
            finally
            {
                await log.DisposeAsync();
                kernel.Dispose();
            }
        }

        private static IWebHostBuilder CreateWebHostBuilder(IGBaseServerSettings serverSettings)
        {
            IWebHostBuilder webHostBuilder = WebHost.CreateDefaultBuilder()
                .UseKestrel(options => { options.Listen(serverSettings.IpAddress, serverSettings.Port); })
                .UseUrls($"{serverSettings.Protocol.GetProtocolString()}{serverSettings.IpAddress}:{serverSettings.Port}")
                .ConfigureAppConfiguration((hostingContext, config) =>
                {
                    config.AddCommandLine(new[]
                    {
                        $"--{GBaseServerSettings.GBASE_ENDPOINT_STARTUP_CONFIGURATION_PREFIX}", serverSettings.GBaseEndpoint,
                        $"--{GBaseServerSettings.GBASE_TABLE_ENDPOINT_STARTUP_CONFIGURATION_PREFIX}", serverSettings.GBaseTableEndpoint,
                        $"--{GBaseServerSettings.GBASE_ENTRY_ENDPOINT_STARTUP_CONFIGURATION_PREFIX}", serverSettings.GBaseEntryEndpoint
                    });
                })
                .UseStartup<Startup>();

            if (serverSettings.Protocol == ServerProtocol.Tcp)
                webHostBuilder.UseNetTcp(serverSettings.Port);

            return webHostBuilder;
        }
    }
}