rework server responsibilities (#18)

* rework server responsibilities
add remote configuration

* start metrics only when compiled as not debug

* add some more logging to discord bot

* fixes of some casts

* make metrics port configurable, minor fixes

* add docker bullshit

* md formatting

* adjustments to docker stuff

* fix docker json files, fix some stuff in discord bot, add /useradd for Discord bot

* adjust docker configs and fix sharded.bat

* fixes for logs, cache file provider repeat trying to open filestream

Co-authored-by: rootdarkarchon <root.darkarchon@outlook.com>

MareSynchronosServer/MareSynchronosServer/Startup.cs

@@ -1,11 +1,5 @@
-using System;
 using MareSynchronos.API;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Hosting;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
 using MareSynchronosServer.Hubs;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.AspNetCore.Http.Connections;
@@ -16,15 +10,14 @@ using MareSynchronosShared.Authentication;
 using MareSynchronosShared.Data;
 using MareSynchronosShared.Protos;
 using Grpc.Net.Client.Configuration;
-using Prometheus;
 using MareSynchronosShared.Metrics;
-using System.Collections.Generic;
 using MareSynchronosServer.Services;
-using System.Net.Http;
 using MareSynchronosServer.Utils;
 using MareSynchronosServer.RequirementHandlers;
-using Microsoft.Extensions.Logging;
 using MareSynchronosShared.Utils;
+using MareSynchronosServer.Identity;
+using MareSynchronosShared.Services;
+using Prometheus;
 
 namespace MareSynchronosServer;
 
@@ -41,98 +34,91 @@ public class Startup
     {
         services.AddHttpContextAccessor();
 
-        services.Configure<ServerConfiguration>(Configuration.GetRequiredSection("MareSynchronos"));
-        services.Configure<MareConfigurationAuthBase>(Configuration.GetRequiredSection("MareSynchronos"));
-        services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
-        services.Configure<IpRateLimitPolicies>(Configuration.GetSection("IpRateLimitPolicies"));
         services.AddTransient(_ => Configuration);
 
-        services.AddMemoryCache();
-        services.AddInMemoryRateLimiting();
-
-        services.AddSingleton<SystemInfoService, SystemInfoService>();
-        services.AddSingleton<IUserIdProvider, IdBasedUserIdProvider>();
-
         var mareConfig = Configuration.GetRequiredSection("MareSynchronos");
 
-        var defaultMethodConfig = new MethodConfig
-        {
-            Names = { MethodName.Default },
-            RetryPolicy = new RetryPolicy
-            {
-                MaxAttempts = 1000,
-                InitialBackoff = TimeSpan.FromSeconds(1),
-                MaxBackoff = TimeSpan.FromSeconds(5),
-                BackoffMultiplier = 1.5,
-                RetryableStatusCodes = { Grpc.Core.StatusCode.Unavailable }
-            }
-        };
+        // configure metrics
+        ConfigureMetrics(services);
 
-        var noRetryConfig = new MethodConfig
-        {
-            Names = { MethodName.Default },
-            RetryPolicy = null
-        };
+        // configure file service grpc connection
+        ConfigureFileServiceGrpcClient(services, mareConfig);
 
-        services.AddSingleton<MareMetrics>(m => new MareMetrics(m.GetService<ILogger<MareMetrics>>(), new List<string>
-        {
-            MetricsAPI.CounterInitializedConnections,
-            MetricsAPI.CounterUserPushData,
-            MetricsAPI.CounterUserPushDataTo,
-            MetricsAPI.CounterUsersRegisteredDeleted,
-            MetricsAPI.CounterAuthenticationCacheHits,
-            MetricsAPI.CounterAuthenticationFailures,
-            MetricsAPI.CounterAuthenticationRequests,
-            MetricsAPI.CounterAuthenticationSuccesses
-        }, new List<string>
-        {
-            MetricsAPI.GaugeAuthorizedConnections,
-            MetricsAPI.GaugeConnections,
-            MetricsAPI.GaugePairs,
-            MetricsAPI.GaugePairsPaused,
-            MetricsAPI.GaugeAvailableIOWorkerThreads,
-            MetricsAPI.GaugeAvailableWorkerThreads,
-            MetricsAPI.GaugeGroups,
-            MetricsAPI.GaugeGroupPairs,
-            MetricsAPI.GaugeGroupPairsPaused
-        }));
+        // configure database
+        ConfigureDatabase(services, mareConfig);
 
-        services.AddGrpcClient<FileService.FileServiceClient>(c =>
+        // configure authentication and authorization
+        ConfigureAuthorization(services);
+
+        // configure rate limiting
+        ConfigureIpRateLimiting(services);
+
+        // configure SignalR
+        ConfigureSignalR(services, mareConfig);
+
+        // configure mare specific services
+        ConfigureMareServices(services, mareConfig);
+    }
+
+    private static void ConfigureMareServices(IServiceCollection services, IConfigurationSection mareConfig)
+    {
+        bool isMainServer = mareConfig.GetValue<Uri>(nameof(ServerConfiguration.MainServerGrpcAddress), defaultValue: null) == null;
+
+        services.Configure<ServerConfiguration>(mareConfig);
+        services.Configure<MareConfigurationBase>(mareConfig);
+        services.Configure<MareConfigurationAuthBase>(mareConfig);
+
+        services.AddSingleton<SystemInfoService>();
+        services.AddSingleton<IUserIdProvider, IdBasedUserIdProvider>();
+        services.AddHostedService(provider => provider.GetService<SystemInfoService>());
+        // configure services based on main server status
+        ConfigureIdentityServices(services, mareConfig, isMainServer);
+
+        if (isMainServer)
         {
-            c.Address = new Uri(mareConfig.GetValue<string>(nameof(ServerConfiguration.StaticFileServiceAddress)));
-        }).ConfigureChannel(c =>
+            services.AddSingleton<UserCleanupService>();
+            services.AddHostedService(provider => provider.GetService<UserCleanupService>());
+        }
+    }
+
+    private static void ConfigureSignalR(IServiceCollection services, IConfigurationSection mareConfig)
+    {
+        var signalRServiceBuilder = services.AddSignalR(hubOptions =>
         {
-            c.ServiceConfig = new ServiceConfig { MethodConfigs = { defaultMethodConfig } };
-        });
-        services.AddGrpcClient<IdentificationService.IdentificationServiceClient>(c =>
-        {
-            c.Address = new Uri(mareConfig.GetValue<string>(nameof(ServerConfiguration.ServiceAddress)));
-        }).ConfigureChannel(c =>
-        {
-            c.ServiceConfig = new ServiceConfig { MethodConfigs = { noRetryConfig } };
-            c.HttpHandler = new SocketsHttpHandler()
-            {
-                EnableMultipleHttp2Connections = true
-            };
+            hubOptions.MaximumReceiveMessageSize = long.MaxValue;
+            hubOptions.EnableDetailedErrors = true;
+            hubOptions.MaximumParallelInvocationsPerClient = 10;
+            hubOptions.StreamBufferCapacity = 200;
+
+            hubOptions.AddFilter<SignalRLimitFilter>();
         });
 
+        // configure redis for SignalR
+        var redis = mareConfig.GetValue(nameof(ServerConfiguration.RedisConnectionString), string.Empty);
+        if (!string.IsNullOrEmpty(redis))
+        {
+            signalRServiceBuilder.AddStackExchangeRedis(redis, options =>
+            {
+                options.Configuration.ChannelPrefix = "MareSynchronos";
+            });
+        }
+    }
+
+    private void ConfigureIpRateLimiting(IServiceCollection services)
+    {
+        services.Configure<IpRateLimitOptions>(Configuration.GetSection("IpRateLimiting"));
+        services.Configure<IpRateLimitPolicies>(Configuration.GetSection("IpRateLimitPolicies"));
+        services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
+        services.AddMemoryCache();
+        services.AddInMemoryRateLimiting();
+    }
+
+    private static void ConfigureAuthorization(IServiceCollection services)
+    {
         services.AddSingleton<SecretKeyAuthenticatorService>();
-        services.AddSingleton<GrpcClientIdentificationService>();
         services.AddTransient<IAuthorizationHandler, UserRequirementHandler>();
-        services.AddHostedService(p => p.GetService<GrpcClientIdentificationService>());
-
-        services.AddDbContextPool<MareDbContext>(options =>
-        {
-            options.UseNpgsql(Configuration.GetConnectionString("DefaultConnection"), builder =>
-            {
-                builder.MigrationsHistoryTable("_efmigrationshistory", "public");
-                builder.MigrationsAssembly("MareSynchronosShared");
-            }).UseSnakeCaseNamingConvention();
-            options.EnableThreadSafetyChecks(false);
-        }, mareConfig.GetValue(nameof(MareConfigurationBase.DbContextPoolSize), 1024));
-
         services.AddAuthentication(SecretKeyAuthenticationHandler.AuthScheme)
-            .AddScheme<AuthenticationSchemeOptions, SecretKeyAuthenticationHandler>(SecretKeyAuthenticationHandler.AuthScheme, options => { options.Validate(); });
+           .AddScheme<AuthenticationSchemeOptions, SecretKeyAuthenticationHandler>(SecretKeyAuthenticationHandler.AuthScheme, options => { options.Validate(); });
 
         services.AddAuthorization(options =>
         {
@@ -157,44 +143,127 @@ public class Startup
                 policy.AddRequirements(new UserRequirement(UserRequirements.Identified | UserRequirements.Moderator | UserRequirements.Administrator));
             });
         });
-
-        services.AddSingleton<IRateLimitConfiguration, RateLimitConfiguration>();
-
-        var signalRServiceBuilder = services.AddSignalR(hubOptions =>
-        {
-            hubOptions.MaximumReceiveMessageSize = long.MaxValue;
-            hubOptions.EnableDetailedErrors = true;
-            hubOptions.MaximumParallelInvocationsPerClient = 10;
-            hubOptions.StreamBufferCapacity = 200;
-
-            hubOptions.AddFilter<SignalRLimitFilter>();
-        });
-
-        // add redis related options
-        var redis = mareConfig.GetValue(nameof(ServerConfiguration.RedisConnectionString), string.Empty);
-        if (!string.IsNullOrEmpty(redis))
-        {
-            signalRServiceBuilder.AddStackExchangeRedis(redis, options =>
-            {
-                options.Configuration.ChannelPrefix = "MareSynchronos";
-            });
-        }
-
-        services.AddHostedService(provider => provider.GetService<SystemInfoService>());
     }
 
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
+    private void ConfigureDatabase(IServiceCollection services, IConfigurationSection mareConfig)
     {
-        if (env.IsDevelopment())
+        services.AddDbContextPool<MareDbContext>(options =>
         {
-            app.UseDeveloperExceptionPage();
-            app.UseMigrationsEndPoint();
+            options.UseNpgsql(Configuration.GetConnectionString("DefaultConnection"), builder =>
+            {
+                builder.MigrationsHistoryTable("_efmigrationshistory", "public");
+                builder.MigrationsAssembly("MareSynchronosShared");
+            }).UseSnakeCaseNamingConvention();
+            options.EnableThreadSafetyChecks(false);
+        }, mareConfig.GetValue(nameof(MareConfigurationBase.DbContextPoolSize), 1024));
+    }
+
+    private static void ConfigureMetrics(IServiceCollection services)
+    {
+        services.AddSingleton<MareMetrics>(m => new MareMetrics(m.GetService<ILogger<MareMetrics>>(), new List<string>
+        {
+            MetricsAPI.CounterInitializedConnections,
+            MetricsAPI.CounterUserPushData,
+            MetricsAPI.CounterUserPushDataTo,
+            MetricsAPI.CounterUsersRegisteredDeleted,
+            MetricsAPI.CounterAuthenticationCacheHits,
+            MetricsAPI.CounterAuthenticationFailures,
+            MetricsAPI.CounterAuthenticationRequests,
+            MetricsAPI.CounterAuthenticationSuccesses,
+        }, new List<string>
+        {
+            MetricsAPI.GaugeAuthorizedConnections,
+            MetricsAPI.GaugeConnections,
+            MetricsAPI.GaugePairs,
+            MetricsAPI.GaugePairsPaused,
+            MetricsAPI.GaugeAvailableIOWorkerThreads,
+            MetricsAPI.GaugeAvailableWorkerThreads,
+            MetricsAPI.GaugeGroups,
+            MetricsAPI.GaugeGroupPairs,
+            MetricsAPI.GaugeGroupPairsPaused,
+            MetricsAPI.GaugeUsersRegistered
+        }));
+    }
+
+    private static void ConfigureIdentityServices(IServiceCollection services, IConfigurationSection mareConfig, bool isMainServer)
+    {
+        if (!isMainServer)
+        {
+            var noRetryConfig = new MethodConfig
+            {
+                Names = { MethodName.Default },
+                RetryPolicy = null
+            };
+
+            services.AddGrpcClient<IdentificationService.IdentificationServiceClient>(c =>
+            {
+                c.Address = new Uri(mareConfig.GetValue<string>(nameof(ServerConfiguration.MainServerGrpcAddress)));
+            }).ConfigureChannel(c =>
+            {
+                c.ServiceConfig = new ServiceConfig { MethodConfigs = { noRetryConfig } };
+                c.HttpHandler = new SocketsHttpHandler()
+                {
+                    EnableMultipleHttp2Connections = true
+                };
+            });
+
+            services.AddGrpcClient<ConfigurationService.ConfigurationServiceClient>(c =>
+            {
+                c.Address = new Uri(mareConfig.GetValue<string>(nameof(ServerConfiguration.MainServerGrpcAddress)));
+            }).ConfigureChannel(c =>
+            {
+                c.ServiceConfig = new ServiceConfig { MethodConfigs = { noRetryConfig } };
+                c.HttpHandler = new SocketsHttpHandler()
+                {
+                    EnableMultipleHttp2Connections = true
+                };
+            });
+
+            services.AddSingleton<IClientIdentificationService, GrpcClientIdentificationService>();
+            services.AddHostedService(p => p.GetService<IClientIdentificationService>());
+            services.AddSingleton<IConfigurationService<ServerConfiguration>, MareConfigurationServiceClient<ServerConfiguration>>();
+            services.AddSingleton<IConfigurationService<MareConfigurationAuthBase>, MareConfigurationServiceClient<MareConfigurationAuthBase>>();
         }
         else
         {
-            app.UseExceptionHandler("/Error");
-            app.UseHsts();
+            services.AddSingleton<IdentityHandler>();
+            services.AddSingleton<IClientIdentificationService, LocalClientIdentificationService>();
+            services.AddSingleton<IConfigurationService<ServerConfiguration>, MareConfigurationServiceServer<ServerConfiguration>>();
+            services.AddSingleton<IConfigurationService<MareConfigurationAuthBase>, MareConfigurationServiceServer<MareConfigurationAuthBase>>();
+
+            services.AddGrpc();
         }
+    }
+
+    private static void ConfigureFileServiceGrpcClient(IServiceCollection services, IConfigurationSection mareConfig)
+    {
+        var defaultMethodConfig = new MethodConfig
+        {
+            Names = { MethodName.Default },
+            RetryPolicy = new RetryPolicy
+            {
+                MaxAttempts = 1000,
+                InitialBackoff = TimeSpan.FromSeconds(1),
+                MaxBackoff = TimeSpan.FromSeconds(5),
+                BackoffMultiplier = 1.5,
+                RetryableStatusCodes = { Grpc.Core.StatusCode.Unavailable }
+            }
+        };
+        services.AddGrpcClient<FileService.FileServiceClient>((serviceProvider, c) =>
+        {
+            c.Address = serviceProvider.GetRequiredService<IConfigurationService<ServerConfiguration>>()
+                .GetValue<Uri>(nameof(ServerConfiguration.StaticFileServiceAddress));
+        }).ConfigureChannel(c =>
+        {
+            c.ServiceConfig = new ServiceConfig { MethodConfigs = { defaultMethodConfig } };
+        });
+    }
+
+    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILogger<Startup> logger)
+    {
+        logger.LogInformation("Running Configure");
+
+        var config = app.ApplicationServices.GetRequiredService<IConfigurationService<MareConfigurationAuthBase>>();
 
         app.UseIpRateLimiting();
 
@@ -202,7 +271,7 @@ public class Startup
 
         app.UseWebSockets();
 
-        var metricServer = new KestrelMetricServer(4980);
+        var metricServer = new KestrelMetricServer(config.GetValueOrDefault<int>(nameof(MareConfigurationBase.MetricsPort), 4981));
         metricServer.Start();
 
         app.UseAuthentication();
@@ -216,6 +285,12 @@ public class Startup
                 options.TransportMaxBufferSize = 5242880;
                 options.Transports = HttpTransportType.WebSockets | HttpTransportType.ServerSentEvents | HttpTransportType.LongPolling;
             });
+
+            if (config.IsMain)
+            {
+                endpoints.MapGrpcService<GrpcIdentityService>().AllowAnonymous();
+                endpoints.MapGrpcService<GrpcConfigurationService<ServerConfiguration>>().AllowAnonymous();
+            }
         });
     }
 }