Program.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using System.Net;
using System.Globalization;
using Microsoft.AspNetCore.Server.Kestrel.Https;
using Microsoft.AspNetCore.Server.Kestrel.Transport.Abstractions.Internal;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json;

namespace HashServer
{
 public class Program
 {
 public static AppOptions Settings;
 public static ILogger log { get; set; }

 public IConfigurationRoot Configuration { get; set; }


 public void ConfigureServices(IServiceCollection services)
 {
 services.AddOptions();
 // Register the IConfiguration instance which MyOptions binds against.
 services.Configure<AppOptions>(Configuration);
 }

 public static Task Main(string[] args)
 {
 TaskScheduler.UnobservedTaskException += (sender, e) =>
 {
 Console.WriteLine("Unobserved exception: {0}", e.Exception);
 };

 var configuration = new ConfigurationBuilder()
 .AddEnvironmentVariables()
 .SetBasePath(Directory.GetCurrentDirectory())
 .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
 .Build();
 Settings = configuration.GetSection("App").Get<AppOptions>();

 Settings.ToString();

 var basePort = Settings.Host.BasePort;
 
 var host = new WebHostBuilder()
 .ConfigureLogging((_, factory) =>
 {
 factory.ClearProviders();
 factory.SetMinimumLevel(Enum.Parse<LogLevel>(Settings.Host.LogLevel));
 factory.AddConsole();
 })
 .UseKestrel(options =>
 {
 // Run callbacks on the transport thread
 options.ApplicationSchedulingMode = SchedulingMode.ThreadPool;
 options.Listen(IPAddress.Any, basePort, listenOptions =>
 {
 // Uncomment the following to enable Nagle's algorithm for this endpoint.
 listenOptions.NoDelay = false;
 listenOptions.KestrelServerOptions.Limits.MaxConcurrentConnections = Settings.Host.MaxConcurrentConnections;
 listenOptions.KestrelServerOptions.Limits.KeepAliveTimeout = TimeSpan.FromSeconds(1);
 listenOptions.KestrelServerOptions.AllowSynchronousIO = true;
 listenOptions.UseConnectionLogging();
 });

 options.Listen(IPAddress.Loopback, basePort + 1, listenOptions =>
 {
 listenOptions.UseHttps(Settings.Host.CertificateFile, Settings.Host.CertificatePassword);
 listenOptions.UseConnectionLogging();
 });
 })
 .UseLibuv(options =>
 {
#if DEBUG
 options.ThreadCount = 1;
#else
 options.ThreadCount = Settings.Host.ThreadCount;
#endif
 })
 .UseContentRoot(Directory.GetCurrentDirectory())
 .UseUrls(Settings.Internal.gRoot, Settings.InternalSSL.gRoot)
 .UseStartup<Startup>()
 .Build();
 return host.RunAsync();
 }
 }
}