InstanceFactory.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Prometheus;
 
using Tgstation.Server.Host.Components.Chat;
using Tgstation.Server.Host.Components.Chat.Commands;
using Tgstation.Server.Host.Components.Deployment;
using Tgstation.Server.Host.Components.Deployment.Remote;
using Tgstation.Server.Host.Components.Engine;
using Tgstation.Server.Host.Components.Events;
using Tgstation.Server.Host.Components.Interop.Bridge;
using Tgstation.Server.Host.Components.Repository;
using Tgstation.Server.Host.Components.Session;
using Tgstation.Server.Host.Components.Watchdog;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.Database;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Jobs;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Transfer;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Components
{
    sealed class InstanceFactory : IInstanceFactory
    {
        readonly IIOManager ioManager;
 
        readonly IDatabaseContextFactory databaseContextFactory;
 
        readonly IAssemblyInformationProvider assemblyInformationProvider;
 
        readonly ILoggerFactory loggerFactory;
 
        readonly ITopicClientFactory topicClientFactory;
 
        readonly ICryptographySuite cryptographySuite;
 
        readonly ISynchronousIOManager synchronousIOManager;
 
        readonly IFilesystemLinkFactory linkFactory;
 
        readonly IEngineInstaller engineInstaller;
 
        readonly IChatManagerFactory chatFactory;
 
        readonly IProcessExecutor processExecutor;
 
        readonly IPostWriteHandler postWriteHandler;
 
        readonly IWatchdogFactory watchdogFactory;
 
        readonly IJobManager jobManager;
 
        readonly INetworkPromptReaper networkPromptReaper;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly IRepositoryManagerFactory repositoryManagerFactory;
 
        readonly IServerPortProvider serverPortProvider;
 
        readonly IFileTransferTicketProvider fileTransferService;
 
        readonly IRemoteDeploymentManagerFactory remoteDeploymentManagerFactory;
 
        readonly IAsyncDelayer asyncDelayer;
 
        readonly IDotnetDumpService dotnetDumpService;
 
        readonly IMetricFactory metricFactory;
 
        readonly IOptionsMonitor<GeneralConfiguration> generalConfigurationOptions;
 
        readonly IOptionsMonitor<SessionConfiguration> sessionConfigurationOptions;
 
        static IIOManager CreateGameIOManager(IIOManager instanceIOManager) => instanceIOManager.CreateResolverForSubdirectory("Game");
 
#pragma warning disable CA1502 // TODO: Decomplexify
        public InstanceFactory(
            IIOManager ioManager,
            IDatabaseContextFactory databaseContextFactory,
            IAssemblyInformationProvider assemblyInformationProvider,
            ILoggerFactory loggerFactory,
            ITopicClientFactory topicClientFactory,
            ICryptographySuite cryptographySuite,
            ISynchronousIOManager synchronousIOManager,
            IFilesystemLinkFactory linkFactory,
            IEngineInstaller engineInstaller,
            IChatManagerFactory chatFactory,
            IProcessExecutor processExecutor,
            IPostWriteHandler postWriteHandler,
            IWatchdogFactory watchdogFactory,
            IJobManager jobManager,
            INetworkPromptReaper networkPromptReaper,
            IPlatformIdentifier platformIdentifier,
            IRepositoryManagerFactory repositoryManagerFactory,
            IServerPortProvider serverPortProvider,
            IFileTransferTicketProvider fileTransferService,
            IRemoteDeploymentManagerFactory remoteDeploymentManagerFactory,
            IAsyncDelayer asyncDelayer,
            IDotnetDumpService dotnetDumpService,
            IMetricFactory metricFactory,
            IOptionsMonitor<GeneralConfiguration> generalConfigurationOptions,
            IOptionsMonitor<SessionConfiguration> sessionConfigurationOptions)
        {
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.databaseContextFactory = databaseContextFactory ?? throw new ArgumentNullException(nameof(databaseContextFactory));
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
            this.topicClientFactory = topicClientFactory ?? throw new ArgumentNullException(nameof(topicClientFactory));
            this.cryptographySuite = cryptographySuite ?? throw new ArgumentNullException(nameof(cryptographySuite));
            this.synchronousIOManager = synchronousIOManager ?? throw new ArgumentNullException(nameof(synchronousIOManager));
            this.linkFactory = linkFactory ?? throw new ArgumentNullException(nameof(linkFactory));
            this.engineInstaller = engineInstaller ?? throw new ArgumentNullException(nameof(engineInstaller));
            this.chatFactory = chatFactory ?? throw new ArgumentNullException(nameof(chatFactory));
            this.processExecutor = processExecutor ?? throw new ArgumentNullException(nameof(processExecutor));
            this.postWriteHandler = postWriteHandler ?? throw new ArgumentNullException(nameof(postWriteHandler));
            this.watchdogFactory = watchdogFactory ?? throw new ArgumentNullException(nameof(watchdogFactory));
            this.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager));
            this.networkPromptReaper = networkPromptReaper ?? throw new ArgumentNullException(nameof(networkPromptReaper));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            this.repositoryManagerFactory = repositoryManagerFactory ?? throw new ArgumentNullException(nameof(repositoryManagerFactory));
            this.serverPortProvider = serverPortProvider ?? throw new ArgumentNullException(nameof(serverPortProvider));
            this.fileTransferService = fileTransferService ?? throw new ArgumentNullException(nameof(fileTransferService));
            this.remoteDeploymentManagerFactory = remoteDeploymentManagerFactory ?? throw new ArgumentNullException(nameof(remoteDeploymentManagerFactory));
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            this.dotnetDumpService = dotnetDumpService ?? throw new ArgumentNullException(nameof(dotnetDumpService));
            this.metricFactory = metricFactory ?? throw new ArgumentNullException(nameof(metricFactory));
            this.generalConfigurationOptions = generalConfigurationOptions ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
            this.sessionConfigurationOptions = sessionConfigurationOptions ?? throw new ArgumentNullException(nameof(sessionConfigurationOptions));
        }
#pragma warning restore CA1502
 
        public IIOManager CreateGameIOManager(Models.Instance metadata)
        {
            ArgumentNullException.ThrowIfNull(metadata);
 
            var instanceIoManager = CreateInstanceIOManager(metadata);
            return CreateGameIOManager(instanceIoManager);
        }
 
#pragma warning disable CA1506 // TODO: Decomplexify
        public async ValueTask<IInstance> CreateInstance(IBridgeRegistrar bridgeRegistrar, Models.Instance metadata)
        {
            ArgumentNullException.ThrowIfNull(bridgeRegistrar);
            ArgumentNullException.ThrowIfNull(metadata);
 
            // Create the ioManager for the instance
            var instanceIoManager = CreateInstanceIOManager(metadata);
 
            // various other ioManagers
            var repoIoManager = instanceIoManager.CreateResolverForSubdirectory("Repository");
            var byondIOManager = instanceIoManager.CreateResolverForSubdirectory("Byond");
            var gameIoManager = CreateGameIOManager(instanceIoManager);
            var diagnosticsIOManager = instanceIoManager.CreateResolverForSubdirectory("Diagnostics");
            var configurationIoManager = instanceIoManager.CreateResolverForSubdirectory("Configuration");
 
            var metricFactory = this.metricFactory.WithLabels(
                new Dictionary<string, string>
                {
                    { "instance_name", metadata.Name! },
                    { "instance_id", metadata.Id!.Value.ToString(CultureInfo.InvariantCulture) },
                });
 
            var configuration = new StaticFiles.Configuration(
                configurationIoManager,
                synchronousIOManager,
                linkFactory,
                processExecutor,
                postWriteHandler,
                platformIdentifier,
                fileTransferService,
                generalConfigurationOptions,
                sessionConfigurationOptions,
                loggerFactory.CreateLogger<StaticFiles.Configuration>(),
                metadata);
            var eventConsumer = new EventConsumer(configuration);
            var repoManager = repositoryManagerFactory.CreateRepositoryManager(repoIoManager, eventConsumer);
            try
            {
                var dmbFactory = new DmbFactory(
                    databaseContextFactory,
                    gameIoManager,
                    remoteDeploymentManagerFactory,
                    eventConsumer,
                    asyncDelayer,
                    loggerFactory.CreateLogger<DmbFactory>(),
                    metadata);
                try
                {
                    var engineManager = new EngineManager(
                        byondIOManager,
                        engineInstaller,
                        eventConsumer,
                        dmbFactory,
                        loggerFactory.CreateLogger<EngineManager>());
                    try
                    {
                        var commandFactory = new CommandFactory(assemblyInformationProvider, engineManager, repoManager, databaseContextFactory, dmbFactory, metadata);
 
                        var chatManager = chatFactory.CreateChatManager(commandFactory, metadata.ChatSettings);
                        try
                        {
                            var reattachInfoHandler = new SessionPersistor(
                                databaseContextFactory,
                                dmbFactory,
                                processExecutor,
                                loggerFactory.CreateLogger<SessionPersistor>(),
                                metadata);
 
                            var dreamMaker = new DreamMaker(
                                engineManager,
                                gameIoManager,
                                configuration,
                                eventConsumer,
                                chatManager,
                                processExecutor,
                                dmbFactory,
                                repoManager,
                                remoteDeploymentManagerFactory,
                                asyncDelayer,
                                metricFactory,
                                sessionConfigurationOptions,
                                loggerFactory.CreateLogger<DreamMaker>(),
                                metadata);
 
                            var sessionControllerFactory = new SessionControllerFactory(
                                processExecutor,
                                engineManager,
                                topicClientFactory,
                                cryptographySuite,
                                assemblyInformationProvider,
                                gameIoManager,
                                diagnosticsIOManager,
                                chatManager,
                                networkPromptReaper,
                                platformIdentifier,
                                bridgeRegistrar,
                                serverPortProvider,
                                eventConsumer,
                                jobManager,
                                dreamMaker,
                                asyncDelayer,
                                dotnetDumpService,
                                metricFactory,
                                loggerFactory,
                                sessionConfigurationOptions,
                                loggerFactory.CreateLogger<SessionControllerFactory>(),
                                metadata);
 
                            dreamMaker.SetSessionControllerFactory(sessionControllerFactory);
 
                            var watchdog = watchdogFactory.CreateWatchdog(
                                chatManager,
                                dmbFactory,
                                reattachInfoHandler,
                                sessionControllerFactory,
                                gameIoManager,
                                diagnosticsIOManager,
                                configuration, // watchdog doesn't need itself as an event consumer
                                remoteDeploymentManagerFactory,
                                metricFactory,
                                metadata,
                                metadata.DreamDaemonSettings!);
                            try
                            {
                                eventConsumer.SetWatchdog(watchdog);
                                commandFactory.SetWatchdog(watchdog);
 
                                Instance? instance = null;
                                instance = new Instance(
                                    metadata,
                                    repoManager,
                                    engineManager,
                                    dreamMaker,
                                    watchdog,
                                    chatManager,
                                    configuration,
                                    dmbFactory,
                                    jobManager,
                                    eventConsumer,
                                    remoteDeploymentManagerFactory,
                                    asyncDelayer,
                                    loggerFactory.CreateLogger<Instance>());
 
                                return instance;
                            }
                            catch
                            {
                                await watchdog.DisposeAsync();
                                throw;
                            }
                        }
                        catch
                        {
                            await chatManager.DisposeAsync();
                            throw;
                        }
                    }
                    catch
                    {
                        engineManager.Dispose();
                        throw;
                    }
                }
                catch
                {
                    dmbFactory.Dispose();
                    throw;
                }
            }
            catch
            {
                repoManager.Dispose();
                throw;
            }
        }
#pragma warning restore CA1506
 
        public Task StartAsync(CancellationToken cancellationToken)
            => Task.WhenAll(
                repositoryManagerFactory.StartAsync(cancellationToken),
                engineInstaller.CleanCache(cancellationToken));
 
        public Task StopAsync(CancellationToken cancellationToken) => repositoryManagerFactory.StopAsync(cancellationToken);
 
        IIOManager CreateInstanceIOManager(Models.Instance metadata) => ioManager.CreateResolverForSubdirectory(metadata.Path!);
    }
}