ServiceCollectionExtensions.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.Globalization;
 
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.DependencyInjection.Extensions;
using Microsoft.Extensions.Logging;
 
using Serilog;
using Serilog.Configuration;
using Serilog.Sinks.Elasticsearch;
 
using Tgstation.Server.Host.Components.Chat.Providers;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Utils;
using Tgstation.Server.Host.Utils.GitHub;
using Tgstation.Server.Host.Utils.SignalR;
 
namespace Tgstation.Server.Host.Extensions
{
    static class ServiceCollectionExtensions
    {
        static Type? chatProviderFactoryType;
 
        static Type? gitHubServiceFactoryType;
 
        static Type? fileDownloaderType;
 
        static ServiceDescriptor? additionalLoggerProvider;
 
        static ServiceCollectionExtensions()
        {
            UseDefaultServices();
        }
 
        public static void UseChatProviderFactory<TProviderFactory>()
            where TProviderFactory : IProviderFactory
        {
            chatProviderFactoryType = typeof(TProviderFactory);
        }
 
        public static void UseGitHubServiceFactory<TGitHubServiceFactory>()
            where TGitHubServiceFactory : IGitHubServiceFactory
        {
            gitHubServiceFactoryType = typeof(TGitHubServiceFactory);
        }
 
        public static void UseFileDownloader<TFileDownloader>()
            where TFileDownloader : IFileDownloader
        {
            fileDownloaderType = typeof(TFileDownloader);
        }
 
        public static IServiceCollection AddFileDownloader(this IServiceCollection serviceCollection)
        {
            ArgumentNullException.ThrowIfNull(serviceCollection);
 
            serviceCollection.AddSingleton(typeof(IFileDownloader), fileDownloaderType ?? throw new InvalidOperationException("fileDownloaderType not set!"));
 
            return serviceCollection;
        }
 
        public static IServiceCollection AddGitHub(this IServiceCollection serviceCollection)
        {
            ArgumentNullException.ThrowIfNull(serviceCollection);
 
            serviceCollection.AddSingleton<IGitHubClientFactory, GitHubClientFactory>();
            serviceCollection.AddSingleton(typeof(IGitHubServiceFactory), gitHubServiceFactoryType ?? throw new InvalidOperationException("gitHubServiceFactoryType not set!"));
 
            return serviceCollection;
        }
 
        public static void UseAdditionalLoggerProvider<TLoggerProvider>()
            where TLoggerProvider : class, ILoggerProvider
        {
            if (additionalLoggerProvider != null)
                throw new InvalidOperationException("Cannot have multiple additionalLoggerProviders!");
            additionalLoggerProvider = ServiceDescriptor.Singleton<ILoggerProvider, TLoggerProvider>();
        }
 
        public static IServiceCollection AddChatProviderFactory(this IServiceCollection serviceCollection)
        {
            ArgumentNullException.ThrowIfNull(serviceCollection);
 
            return serviceCollection.AddSingleton(typeof(IProviderFactory), chatProviderFactoryType ?? throw new InvalidOperationException("chatProviderFactoryType not set!"));
        }
 
        public static IServiceCollection UseStandardConfig<TConfig>(this IServiceCollection serviceCollection, IConfiguration configuration)
            where TConfig : class
        {
            ArgumentNullException.ThrowIfNull(serviceCollection);
            ArgumentNullException.ThrowIfNull(configuration);
 
            const string SectionFieldName = nameof(GeneralConfiguration.Section);
 
            var configType = typeof(TConfig);
            var sectionField = configType.GetField(SectionFieldName) ?? throw new InvalidOperationException(
                String.Format(CultureInfo.InvariantCulture, "{0} has no {1} field!", configType, SectionFieldName));
            var stringType = typeof(string);
            if (sectionField.FieldType != stringType)
                throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "{0} has invalid {1} field type, must be {2}!", configType, SectionFieldName, stringType));
 
            var sectionName = (string)sectionField.GetValue(null)!;
 
            return serviceCollection.Configure<TConfig>(configuration.GetSection(sectionName));
        }
 
        public static IServiceCollection SetupLogging(
            this IServiceCollection serviceCollection,
            Action<LoggerConfiguration> configurationAction,
            Action<LoggerSinkConfiguration>? sinkConfigurationAction = null,
            ElasticsearchSinkOptions? elasticsearchSinkOptions = null,
            InternalConfiguration? internalConfiguration = null,
            FileLoggingConfiguration? fileLoggingConfiguration = null)
        {
            if (internalConfiguration != null)
                ArgumentNullException.ThrowIfNull(fileLoggingConfiguration);
 
            return serviceCollection.AddLogging(builder =>
            {
                builder.ClearProviders();
 
                var configuration = new LoggerConfiguration()
                    .MinimumLevel
                        .Verbose();
 
                configurationAction?.Invoke(configuration);
 
                configuration
                    .Enrich.FromLogContext()
                    .WriteTo
                    .Async(sinkConfiguration =>
                    {
                        var template = "[{Timestamp:HH:mm:ss}] {Level:w3}: {SourceContext:l} ("
                                + SerilogContextHelper.Template
                                + "){NewLine}    {Message:lj}{NewLine}{Exception}";
 
                        if (!((internalConfiguration?.UsingSystemD ?? false) && !(fileLoggingConfiguration?.Disable ?? false)))
                            sinkConfiguration.Console(outputTemplate: template, formatProvider: CultureInfo.InvariantCulture);
                        sinkConfigurationAction?.Invoke(sinkConfiguration);
                    });
 
                if (elasticsearchSinkOptions != null)
                    configuration.WriteTo.Elasticsearch(elasticsearchSinkOptions);
 
                builder.AddSerilog(configuration.CreateLogger(), true);
 
                if (Debugger.IsAttached)
                    builder.AddDebug();
 
                if (additionalLoggerProvider != null)
                    builder.Services.TryAddEnumerable(additionalLoggerProvider);
            });
        }
 
        public static void AddHub<THub, THubMethods>(this IServiceCollection services)
            where THub : ConnectionMappingHub<THub, THubMethods>
            where THubMethods : class
        {
            ArgumentNullException.ThrowIfNull(services);
 
            services.TryAddSingleton(typeof(ComprehensiveHubContext<,>));
            services.AddSingleton<IConnectionMappedHubContext<THub, THubMethods>>(provider => provider.GetRequiredService<ComprehensiveHubContext<THub, THubMethods>>());
            services.AddSingleton<IHubConnectionMapper<THub, THubMethods>>(provider => provider.GetRequiredService<ComprehensiveHubContext<THub, THubMethods>>());
        }
 
        static void UseDefaultServices()
        {
            UseChatProviderFactory<ProviderFactory>();
            UseGitHubServiceFactory<GitHubServiceFactory>();
            UseFileDownloader<FileDownloader>();
        }
    }
}