InstanceFactory.cs

Go to the documentation of this file.

using System;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
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 GeneralConfiguration generalConfiguration;
 
        readonly SessionConfiguration sessionConfiguration;
 
        static ResolvingIOManager CreateGameIOManager(IIOManager instanceIOManager) => new(instanceIOManager, "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,
            IOptions<GeneralConfiguration> generalConfigurationOptions,
            IOptions<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));
            generalConfiguration = generalConfigurationOptions?.Value ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
            sessionConfiguration = sessionConfigurationOptions?.Value ?? 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 = new ResolvingIOManager(instanceIoManager, "Repository");
            var byondIOManager = new ResolvingIOManager(instanceIoManager, "Byond");
            var gameIoManager = CreateGameIOManager(instanceIoManager);
            var diagnosticsIOManager = new ResolvingIOManager(instanceIoManager, "Diagnostics");
            var configurationIoManager = new ResolvingIOManager(instanceIoManager, "Configuration");
 
            var configuration = new StaticFiles.Configuration(
                configurationIoManager,
                synchronousIOManager,
                linkFactory,
                processExecutor,
                postWriteHandler,
                platformIdentifier,
                fileTransferService,
                loggerFactory.CreateLogger<StaticFiles.Configuration>(),
                generalConfiguration,
                sessionConfiguration);
            var eventConsumer = new EventConsumer(configuration);
            var repoManager = repositoryManagerFactory.CreateRepositoryManager(repoIoManager, eventConsumer);
            try
            {
                var engineManager = new EngineManager(
                    byondIOManager,
                    engineInstaller,
                    eventConsumer,
                    loggerFactory.CreateLogger<EngineManager>());
 
                var dmbFactory = new DmbFactory(
                    databaseContextFactory,
                    gameIoManager,
                    remoteDeploymentManagerFactory,
                    eventConsumer,
                    asyncDelayer,
                    loggerFactory.CreateLogger<DmbFactory>(),
                    metadata);
                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 sessionControllerFactory = new SessionControllerFactory(
                            processExecutor,
                            engineManager,
                            topicClientFactory,
                            cryptographySuite,
                            assemblyInformationProvider,
                            gameIoManager,
                            diagnosticsIOManager,
                            chatManager,
                            networkPromptReaper,
                            platformIdentifier,
                            bridgeRegistrar,
                            serverPortProvider,
                            eventConsumer,
                            asyncDelayer,
                            dotnetDumpService,
                            loggerFactory,
                            loggerFactory.CreateLogger<SessionControllerFactory>(),
                            sessionConfiguration,
                            metadata);
 
                        var watchdog = watchdogFactory.CreateWatchdog(
                            chatManager,
                            dmbFactory,
                            reattachInfoHandler,
                            sessionControllerFactory,
                            gameIoManager,
                            diagnosticsIOManager,
                            configuration, // watchdog doesn't need itself as an event consumer
                            remoteDeploymentManagerFactory,
                            metadata,
                            metadata.DreamDaemonSettings!);
                        try
                        {
                            eventConsumer.SetWatchdog(watchdog);
                            commandFactory.SetWatchdog(watchdog);
 
                            Instance? instance = null;
                            var dreamMaker = new DreamMaker(
                                engineManager,
                                gameIoManager,
                                configuration,
                                sessionControllerFactory,
                                eventConsumer,
                                chatManager,
                                processExecutor,
                                dmbFactory,
                                repoManager,
                                remoteDeploymentManagerFactory,
                                asyncDelayer,
                                loggerFactory.CreateLogger<DreamMaker>(),
                                sessionConfiguration,
                                metadata);
 
                            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
                {
                    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);
 
        ResolvingIOManager CreateInstanceIOManager(Models.Instance metadata) => new(ioManager, metadata.Path!);
    }
}