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.Byond;
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.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 ISymlinkFactory symlinkFactory;
 
        readonly IByondInstaller byondInstaller;
 
        readonly IChatManagerFactory chatFactory;
 
        readonly IProcessExecutor processExecutor;
 
        readonly IPostWriteHandler postWriteHandler;
 
        readonly IWatchdogFactory watchdogFactory;
 
        readonly IJobManager jobManager;
 
        readonly INetworkPromptReaper networkPromptReaper;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly ILibGit2RepositoryFactory repositoryFactory;
 
        readonly ILibGit2Commands repositoryCommands;
 
        readonly IServerPortProvider serverPortProvider;
 
        readonly IFileTransferTicketProvider fileTransferService;
 
        readonly IGitRemoteFeaturesFactory gitRemoteFeaturesFactory;
 
        readonly IRemoteDeploymentManagerFactory remoteDeploymentManagerFactory;
 
        readonly IAsyncDelayer asyncDelayer;
 
        readonly GeneralConfiguration generalConfiguration;
 
        readonly SessionConfiguration sessionConfiguration;
 
        static IIOManager CreateGameIOManager(IIOManager instanceIOManager) => new ResolvingIOManager(instanceIOManager, "Game");
 
#pragma warning disable CA1502 // TODO: Decomplexify
        public InstanceFactory(
            IIOManager ioManager,
            IDatabaseContextFactory databaseContextFactory,
            IAssemblyInformationProvider assemblyInformationProvider,
            ILoggerFactory loggerFactory,
            ITopicClientFactory topicClientFactory,
            ICryptographySuite cryptographySuite,
            ISynchronousIOManager synchronousIOManager,
            ISymlinkFactory symlinkFactory,
            IByondInstaller byondInstaller,
            IChatManagerFactory chatFactory,
            IProcessExecutor processExecutor,
            IPostWriteHandler postWriteHandler,
            IWatchdogFactory watchdogFactory,
            IJobManager jobManager,
            INetworkPromptReaper networkPromptReaper,
            IPlatformIdentifier platformIdentifier,
            ILibGit2RepositoryFactory repositoryFactory,
            ILibGit2Commands repositoryCommands,
            IServerPortProvider serverPortProvider,
            IFileTransferTicketProvider fileTransferService,
            IGitRemoteFeaturesFactory gitRemoteFeaturesFactory,
            IRemoteDeploymentManagerFactory remoteDeploymentManagerFactory,
            IAsyncDelayer asyncDelayer,
            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.symlinkFactory = symlinkFactory ?? throw new ArgumentNullException(nameof(symlinkFactory));
            this.byondInstaller = byondInstaller ?? throw new ArgumentNullException(nameof(byondInstaller));
            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.repositoryFactory = repositoryFactory ?? throw new ArgumentNullException(nameof(repositoryFactory));
            this.repositoryCommands = repositoryCommands ?? throw new ArgumentNullException(nameof(repositoryCommands));
            this.serverPortProvider = serverPortProvider ?? throw new ArgumentNullException(nameof(serverPortProvider));
            this.fileTransferService = fileTransferService ?? throw new ArgumentNullException(nameof(fileTransferService));
            this.gitRemoteFeaturesFactory = gitRemoteFeaturesFactory ?? throw new ArgumentNullException(nameof(gitRemoteFeaturesFactory));
            this.remoteDeploymentManagerFactory = remoteDeploymentManagerFactory ?? throw new ArgumentNullException(nameof(remoteDeploymentManagerFactory));
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            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 Task<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,
                symlinkFactory,
                processExecutor,
                postWriteHandler,
                platformIdentifier,
                fileTransferService,
                loggerFactory.CreateLogger<StaticFiles.Configuration>(),
                generalConfiguration,
                sessionConfiguration);
            var eventConsumer = new EventConsumer(configuration);
            var repoManager = new RepositoryManager(
                repositoryFactory,
                repositoryCommands,
                repoIoManager,
                eventConsumer,
                postWriteHandler,
                gitRemoteFeaturesFactory,
                loggerFactory.CreateLogger<Repository.Repository>(),
                loggerFactory.CreateLogger<RepositoryManager>(),
                generalConfiguration);
            try
            {
                var byond = new ByondManager(byondIOManager, byondInstaller, eventConsumer, loggerFactory.CreateLogger<ByondManager>());
 
                var dmbFactory = new DmbFactory(
                    databaseContextFactory,
                    gameIoManager,
                    remoteDeploymentManagerFactory,
                    eventConsumer,
                    loggerFactory.CreateLogger<DmbFactory>(),
                    metadata);
                try
                {
                    var commandFactory = new CommandFactory(assemblyInformationProvider, byond, 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,
                            byond,
                            topicClientFactory,
                            cryptographySuite,
                            assemblyInformationProvider,
                            gameIoManager,
                            diagnosticsIOManager,
                            chatManager,
                            networkPromptReaper,
                            platformIdentifier,
                            bridgeRegistrar,
                            serverPortProvider,
                            eventConsumer,
                            asyncDelayer,
                            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(
                                byond,
                                gameIoManager,
                                configuration,
                                sessionControllerFactory,
                                eventConsumer,
                                chatManager,
                                processExecutor,
                                dmbFactory,
                                repoManager,
                                remoteDeploymentManagerFactory,
                                asyncDelayer,
                                loggerFactory.CreateLogger<DreamMaker>(),
                                sessionConfiguration,
                                metadata);
 
                            instance = new Instance(
                                metadata,
                                repoManager,
                                byond,
                                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)
        {
            CheckSystemCompatibility();
            return byondInstaller.CleanCache(cancellationToken);
        }
 
        public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
 
        void CheckSystemCompatibility() => repositoryFactory.CreateInMemory();
 
        IIOManager CreateInstanceIOManager(Models.Instance metadata) => new ResolvingIOManager(ioManager, metadata.Path);
    }
}