InstanceFactory.cs

Go to the documentation of this file.

using Byond.TopicSender;
using Microsoft.Extensions.Logging;
using System;
using System.Threading;
using System.Threading.Tasks;
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.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.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;

namespace Tgstation.Server.Host.Components
{
    sealed class InstanceFactory : IInstanceFactory
    {
        readonly IIOManager ioManager;

        readonly IDatabaseContextFactory databaseContextFactory;

        readonly IAssemblyInformationProvider assemblyInformationProvider;

        readonly ILoggerFactory loggerFactory;

        readonly ITopicClient byondTopicSender;

        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 IGitHubClientFactory gitHubClientFactory;

        readonly IPlatformIdentifier platformIdentifier;

        readonly ILibGit2RepositoryFactory repositoryFactory;

        readonly ILibGit2Commands repositoryCommands;

        readonly IServerPortProvider serverPortProvider;

        public InstanceFactory(
            IIOManager ioManager,
            IDatabaseContextFactory databaseContextFactory,
            IAssemblyInformationProvider assemblyInformationProvider,
            ILoggerFactory loggerFactory,
            ITopicClient byondTopicSender,
            ICryptographySuite cryptographySuite,
            ISynchronousIOManager synchronousIOManager,
            ISymlinkFactory symlinkFactory,
            IByondInstaller byondInstaller,
            IChatManagerFactory chatFactory,
            IProcessExecutor processExecutor,
            IPostWriteHandler postWriteHandler,
            IWatchdogFactory watchdogFactory,
            IJobManager jobManager,
            INetworkPromptReaper networkPromptReaper,
            IGitHubClientFactory gitHubClientFactory,
            IPlatformIdentifier platformIdentifier,
            ILibGit2RepositoryFactory repositoryFactory,
            ILibGit2Commands repositoryCommands,
            IServerPortProvider serverPortProvider)
        {
            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.byondTopicSender = byondTopicSender ?? throw new ArgumentNullException(nameof(byondTopicSender));
            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.gitHubClientFactory = gitHubClientFactory ?? throw new ArgumentNullException(nameof(gitHubClientFactory));
            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));
        }

#pragma warning disable CA1506 // TODO: Decomplexify
        public IInstance CreateInstance(IBridgeRegistrar bridgeRegistrar, Models.Instance metadata)
        {
            // Create the ioManager for the instance
            var instanceIoManager = new ResolvingIOManager(ioManager, metadata.Path);

            // various other ioManagers
            var repoIoManager = new ResolvingIOManager(instanceIoManager, "Repository");
            var byondIOManager = new ResolvingIOManager(instanceIoManager, "Byond");
            var gameIoManager = new ResolvingIOManager(instanceIoManager, "Game");
            var configurationIoManager = new ResolvingIOManager(instanceIoManager, "Configuration");

            var configuration = new StaticFiles.Configuration(configurationIoManager, synchronousIOManager, symlinkFactory, processExecutor, postWriteHandler, platformIdentifier, loggerFactory.CreateLogger<StaticFiles.Configuration>());
            var eventConsumer = new EventConsumer(configuration);
            var repoManager = new RepositoryManager(
                repositoryFactory,
                repositoryCommands,
                repoIoManager,
                eventConsumer,
                loggerFactory.CreateLogger<Repository.Repository>(),
                loggerFactory.CreateLogger<RepositoryManager>());
            try
            {
                var byond = new ByondManager(byondIOManager, byondInstaller, eventConsumer, loggerFactory.CreateLogger<ByondManager>());

                var commandFactory = new CommandFactory(assemblyInformationProvider, byond, repoManager, databaseContextFactory, metadata);

                var chatManager = chatFactory.CreateChatManager(instanceIoManager, commandFactory, metadata.ChatSettings);
                try
                {
                    var sessionControllerFactory = new SessionControllerFactory(
                        processExecutor,
                        byond,
                        byondTopicSender,
                        cryptographySuite,
                        assemblyInformationProvider,
                        gameIoManager,
                        chatManager,
                        networkPromptReaper,
                        platformIdentifier,
                        bridgeRegistrar,
                        serverPortProvider,
                        loggerFactory,
                        loggerFactory.CreateLogger<SessionControllerFactory>(),
                        metadata.CloneMetadata());

                    var dmbFactory = new DmbFactory(databaseContextFactory, gameIoManager, loggerFactory.CreateLogger<DmbFactory>(), metadata.CloneMetadata());
                    try
                    {
                        var reattachInfoHandler = new ReattachInfoHandler(databaseContextFactory, dmbFactory, loggerFactory.CreateLogger<ReattachInfoHandler>(), metadata.CloneMetadata());
                        var watchdog = watchdogFactory.CreateWatchdog(
                            chatManager,
                            dmbFactory,
                            reattachInfoHandler,
                            sessionControllerFactory,
                            gameIoManager,
                            metadata.CloneMetadata(),
                            metadata.DreamDaemonSettings);
                        eventConsumer.SetWatchdog(watchdog);
                        commandFactory.SetWatchdog(watchdog);
                        try
                        {
                            Instance instance = null;
                            var dreamMaker = new DreamMaker(
                                byond,
                                gameIoManager,
                                configuration,
                                sessionControllerFactory,
                                eventConsumer,
                                chatManager,
                                processExecutor,
                                gitHubClientFactory,
                                dmbFactory,
                                repoManager,
                                loggerFactory.CreateLogger<DreamMaker>(),
                                metadata.CloneMetadata());

                            instance = new Instance(
                                metadata.CloneMetadata(),
                                repoManager,
                                byond,
                                dreamMaker,
                                watchdog,
                                chatManager,
                                configuration,
                                databaseContextFactory,
                                dmbFactory,
                                jobManager,
                                eventConsumer,
                                loggerFactory.CreateLogger<Instance>());

                            return instance;
                        }
                        catch
                        {
                            watchdog.Dispose();
                            throw;
                        }
                    }
                    catch
                    {
                        dmbFactory.Dispose();
                        throw;
                    }
                }
                catch
                {
                    chatManager.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;

        private void CheckSystemCompatibility() => repositoryFactory.CreateInMemory().Dispose();
    }
}