SessionControllerFactory.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
using Byond.TopicSender;
 
using Microsoft.Extensions.Logging;
 
using Tgstation.Server.Api;
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Internal;
using Tgstation.Server.Host.Components.Byond;
using Tgstation.Server.Host.Components.Chat;
using Tgstation.Server.Host.Components.Deployment;
using Tgstation.Server.Host.Components.Events;
using Tgstation.Server.Host.Components.Interop;
using Tgstation.Server.Host.Components.Interop.Bridge;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.Extensions;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Jobs;
using Tgstation.Server.Host.Security;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Components.Session
{
    sealed class SessionControllerFactory : ISessionControllerFactory
    {
        const string DreamDaemonLogsPath = "DreamDaemonLogs";
 
        readonly IProcessExecutor processExecutor;
 
        readonly IByondManager byond;
 
        readonly ITopicClientFactory topicClientFactory;
 
        readonly ICryptographySuite cryptographySuite;
 
        readonly IAssemblyInformationProvider assemblyInformationProvider;
 
        readonly IIOManager gameIOManager;
 
        readonly IIOManager diagnosticsIOManager;
 
        readonly IChatManager chat;
 
        readonly INetworkPromptReaper networkPromptReaper;
 
        readonly IPlatformIdentifier platformIdentifier;
 
        readonly IBridgeRegistrar bridgeRegistrar;
 
        readonly IServerPortProvider serverPortProvider;
 
        readonly IEventConsumer eventConsumer;
 
        readonly IAsyncDelayer asyncDelayer;
 
        readonly ILoggerFactory loggerFactory;
 
        readonly ILogger<SessionControllerFactory> logger;
 
        readonly SessionConfiguration sessionConfiguration;
 
        readonly Api.Models.Instance instance;
 
        static string SecurityWord(DreamDaemonSecurity securityLevel)
        {
            return securityLevel switch
            {
                DreamDaemonSecurity.Safe => "safe",
                DreamDaemonSecurity.Trusted => "trusted",
                DreamDaemonSecurity.Ultrasafe => "ultrasafe",
                _ => throw new ArgumentOutOfRangeException(nameof(securityLevel), securityLevel, String.Format(CultureInfo.InvariantCulture, "Bad DreamDaemon security level: {0}", securityLevel)),
            };
        }
 
        static string VisibilityWord(DreamDaemonVisibility visibility)
        {
            return visibility switch
            {
                DreamDaemonVisibility.Public => "public",
                DreamDaemonVisibility.Private => "private",
                DreamDaemonVisibility.Invisible => "invisible",
                _ => throw new ArgumentOutOfRangeException(nameof(visibility), visibility, String.Format(CultureInfo.InvariantCulture, "Bad DreamDaemon visibility level: {0}", visibility)),
            };
        }
 
        void PortBindTest(ushort port)
        {
            try
            {
                logger.LogTrace("Bind test: {port}", port);
                SocketExtensions.BindTest(port, false);
            }
            catch (SocketException ex) when (ex.SocketErrorCode == SocketError.AddressAlreadyInUse)
            {
                throw new JobException(ErrorCode.DreamDaemonPortInUse, ex);
            }
        }
 
        public SessionControllerFactory(
            IProcessExecutor processExecutor,
            IByondManager byond,
            ITopicClientFactory topicClientFactory,
            ICryptographySuite cryptographySuite,
            IAssemblyInformationProvider assemblyInformationProvider,
            IIOManager gameIOManager,
            IIOManager diagnosticsIOManager,
            IChatManager chat,
            INetworkPromptReaper networkPromptReaper,
            IPlatformIdentifier platformIdentifier,
            IBridgeRegistrar bridgeRegistrar,
            IServerPortProvider serverPortProvider,
            IEventConsumer eventConsumer,
            IAsyncDelayer asyncDelayer,
            ILoggerFactory loggerFactory,
            ILogger<SessionControllerFactory> logger,
            SessionConfiguration sessionConfiguration,
            Api.Models.Instance instance)
        {
            this.processExecutor = processExecutor ?? throw new ArgumentNullException(nameof(processExecutor));
            this.byond = byond ?? throw new ArgumentNullException(nameof(byond));
            this.topicClientFactory = topicClientFactory ?? throw new ArgumentNullException(nameof(topicClientFactory));
            this.cryptographySuite = cryptographySuite ?? throw new ArgumentNullException(nameof(cryptographySuite));
            this.assemblyInformationProvider = assemblyInformationProvider ?? throw new ArgumentNullException(nameof(assemblyInformationProvider));
            this.gameIOManager = gameIOManager ?? throw new ArgumentNullException(nameof(gameIOManager));
            this.diagnosticsIOManager = diagnosticsIOManager ?? throw new ArgumentNullException(nameof(diagnosticsIOManager));
            this.chat = chat ?? throw new ArgumentNullException(nameof(chat));
            this.networkPromptReaper = networkPromptReaper ?? throw new ArgumentNullException(nameof(networkPromptReaper));
            this.platformIdentifier = platformIdentifier ?? throw new ArgumentNullException(nameof(platformIdentifier));
            this.bridgeRegistrar = bridgeRegistrar ?? throw new ArgumentNullException(nameof(bridgeRegistrar));
            this.serverPortProvider = serverPortProvider ?? throw new ArgumentNullException(nameof(serverPortProvider));
            this.eventConsumer = eventConsumer ?? throw new ArgumentNullException(nameof(eventConsumer));
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
            this.sessionConfiguration = sessionConfiguration ?? throw new ArgumentNullException(nameof(sessionConfiguration));
            this.instance = instance ?? throw new ArgumentNullException(nameof(instance));
        }
 
        public async Task<ISessionController> LaunchNew(
            IDmbProvider dmbProvider,
            IByondExecutableLock currentByondLock,
            DreamDaemonLaunchParameters launchParameters,
            bool apiValidate,
            CancellationToken cancellationToken)
        {
            logger.LogTrace("Begin session launch...");
            if (!launchParameters.Port.HasValue)
                throw new InvalidOperationException("Given port is null!");
            switch (dmbProvider.CompileJob.MinimumSecurityLevel)
            {
                case DreamDaemonSecurity.Ultrasafe:
                    break;
                case DreamDaemonSecurity.Safe:
                    if (launchParameters.SecurityLevel == DreamDaemonSecurity.Ultrasafe)
                    {
                        logger.LogTrace("Boosting security level to minimum of Safe");
                        launchParameters.SecurityLevel = DreamDaemonSecurity.Safe;
                    }
 
                    break;
                case DreamDaemonSecurity.Trusted:
                    if (launchParameters.SecurityLevel != DreamDaemonSecurity.Trusted)
                        logger.LogTrace("Boosting security level to minimum of Trusted");
 
                    launchParameters.SecurityLevel = DreamDaemonSecurity.Trusted;
                    break;
                default:
                    throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Invalid DreamDaemonSecurity value: {0}", dmbProvider.CompileJob.MinimumSecurityLevel));
            }
 
            // get the byond lock
            var byondLock = currentByondLock ?? await byond.UseExecutables(
                Version.Parse(dmbProvider.CompileJob.ByondVersion),
                gameIOManager.ConcatPath(dmbProvider.Directory, dmbProvider.DmbName),
                cancellationToken);
            try
            {
                logger.LogDebug(
                    "Launching session with CompileJob {compileJobId}...",
                    dmbProvider.CompileJob.Id);
 
                PortBindTest(launchParameters.Port.Value);
                await CheckPagerIsNotRunning(cancellationToken);
 
                string outputFilePath = null;
                var preserveLogFile = true;
                if (launchParameters.LogOutput.Value)
                {
                    var now = DateTimeOffset.UtcNow;
                    var dateDirectory = diagnosticsIOManager.ConcatPath(DreamDaemonLogsPath, now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
                    await diagnosticsIOManager.CreateDirectory(dateDirectory, cancellationToken);
                    outputFilePath = diagnosticsIOManager.ResolvePath(
                        diagnosticsIOManager.ConcatPath(
                            dateDirectory,
                            $"dd-utc-{now.ToString("yyyy-MM-dd-HH-mm-ss", CultureInfo.InvariantCulture)}{(apiValidate ? "-dmapi" : String.Empty)}.log"));
 
                    logger.LogInformation("Logging DreamDaemon output to {path}...", outputFilePath);
                }
                else if (!byondLock.SupportsCli)
                {
                    outputFilePath = gameIOManager.ConcatPath(dmbProvider.Directory, $"{Guid.NewGuid()}.dd.log");
                    preserveLogFile = false;
                }
 
                var accessIdentifier = cryptographySuite.GetSecureString();
 
                var byondTopicSender = topicClientFactory.CreateTopicClient(
                    TimeSpan.FromMilliseconds(
                        launchParameters.TopicRequestTimeout.Value));
 
                if (!apiValidate && dmbProvider.CompileJob.DMApiVersion == null)
                    logger.LogDebug("Session will have no DMAPI support!");
 
                // launch dd
                var process = await CreateDreamDaemonProcess(
                    dmbProvider,
                    byondTopicSender,
                    byondLock,
                    launchParameters,
                    accessIdentifier,
                    outputFilePath,
                    apiValidate,
                    cancellationToken);
 
                try
                {
                    var chatTrackingContext = chat.CreateTrackingContext();
 
                    try
                    {
                        var runtimeInformation = CreateRuntimeInformation(
                            dmbProvider,
                            chatTrackingContext,
                            launchParameters,
                            apiValidate);
 
                        var reattachInformation = new ReattachInformation(
                            dmbProvider,
                            process,
                            runtimeInformation,
                            accessIdentifier,
                            launchParameters.Port.Value);
 
                        var sessionController = new SessionController(
                            reattachInformation,
                            instance,
                            process,
                            byondLock,
                            byondTopicSender,
                            chatTrackingContext,
                            bridgeRegistrar,
                            chat,
                            assemblyInformationProvider,
                            asyncDelayer,
                            loggerFactory.CreateLogger<SessionController>(),
                            () => LogDDOutput(
                                process,
                                outputFilePath,
                                byondLock.SupportsCli,
                                preserveLogFile,
                                CancellationToken.None), // DCT: None available
                            launchParameters.StartupTimeout,
                            false,
                            apiValidate);
 
                        return sessionController;
                    }
                    catch
                    {
                        chatTrackingContext.Dispose();
                        throw;
                    }
                }
                catch
                {
                    await using (process)
                    {
                        process.Terminate();
                        await process.Lifetime;
                        throw;
                    }
                }
            }
            catch
            {
                if (currentByondLock == null)
                    byondLock.Dispose();
                throw;
            }
        }
 
        public async Task<ISessionController> Reattach(
            ReattachInformation reattachInformation,
            CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(reattachInformation);
 
            logger.LogTrace("Begin session reattach...");
            var byondTopicSender = topicClientFactory.CreateTopicClient(reattachInformation.TopicRequestTimeout);
            var byondLock = await byond.UseExecutables(
                Version.Parse(reattachInformation.Dmb.CompileJob.ByondVersion),
                null, // Doesn't matter if it's trusted or not on reattach
                cancellationToken);
 
            try
            {
                logger.LogDebug(
                    "Attaching to session PID: {pid}, CompileJob: {compileJobId}...",
                    reattachInformation.ProcessId,
                    reattachInformation.Dmb.CompileJob.Id);
 
                var process = processExecutor.GetProcess(reattachInformation.ProcessId);
                if (process == null)
                    return null;
 
                try
                {
                    if (!byondLock.SupportsCli)
                        networkPromptReaper.RegisterProcess(process);
 
                    var chatTrackingContext = chat.CreateTrackingContext();
                    try
                    {
                        var runtimeInformation = CreateRuntimeInformation(
                            reattachInformation.Dmb,
                            chatTrackingContext,
                            null,
                            false);
                        reattachInformation.SetRuntimeInformation(runtimeInformation);
 
                        var controller = new SessionController(
                            reattachInformation,
                            instance,
                            process,
                            byondLock,
                            byondTopicSender,
                            chatTrackingContext,
                            bridgeRegistrar,
                            chat,
                            assemblyInformationProvider,
                            asyncDelayer,
                            loggerFactory.CreateLogger<SessionController>(),
                            () => Task.CompletedTask,
                            null,
                            true,
                            false);
 
                        process = null;
                        byondLock = null;
                        chatTrackingContext = null;
 
                        return controller;
                    }
                    catch
                    {
                        chatTrackingContext.Dispose();
                        throw;
                    }
                }
                catch
                {
                    await process.DisposeAsync();
                    throw;
                }
            }
            catch
            {
                byondLock.Dispose();
                throw;
            }
        }
 
        async Task<IProcess> CreateDreamDaemonProcess(
            IDmbProvider dmbProvider,
            ITopicClient byondTopicSender,
            IByondExecutableLock byondLock,
            DreamDaemonLaunchParameters launchParameters,
            string accessIdentifier,
            string logFilePath,
            bool apiValidate,
            CancellationToken cancellationToken)
        {
            // set command line options
            // more sanitization here cause it uses the same scheme
            var parameters = $"{DMApiConstants.ParamApiVersion}={byondTopicSender.SanitizeString(DMApiConstants.InteropVersion.Semver().ToString())}&{byondTopicSender.SanitizeString(DMApiConstants.ParamServerPort)}={serverPortProvider.HttpApiPort}&{byondTopicSender.SanitizeString(DMApiConstants.ParamAccessIdentifier)}={byondTopicSender.SanitizeString(accessIdentifier)}";
 
            if (!String.IsNullOrEmpty(launchParameters.AdditionalParameters))
                parameters = $"{parameters}&{launchParameters.AdditionalParameters}";
 
            // important to run on all ports to allow port changing
            var arguments = String.Format(
                CultureInfo.InvariantCulture,
                "{0} -port {1} -ports 1-65535 {2}-close -verbose -{3} -{4}{5}{6} -params \"{7}\"",
                dmbProvider.DmbName,
                launchParameters.Port.Value,
                launchParameters.AllowWebClient.Value ? "-webclient " : String.Empty,
                SecurityWord(launchParameters.SecurityLevel.Value),
                VisibilityWord(launchParameters.Visibility.Value),
                !byondLock.SupportsCli
                    ? $" -logself -log {logFilePath}"
                    : String.Empty, // DD doesn't output anything if -logself is set???
                launchParameters.StartProfiler.Value
                    ? " -profile"
                    : String.Empty,
                parameters);
 
            var process = await processExecutor.LaunchProcess(
                byondLock.DreamDaemonPath,
                dmbProvider.Directory,
                arguments,
                logFilePath,
                byondLock.SupportsCli,
                true);
 
            try
            {
                if (!apiValidate)
                {
                    if (sessionConfiguration.HighPriorityLiveDreamDaemon)
                        process.AdjustPriority(true);
                }
                else if (sessionConfiguration.LowPriorityDeploymentProcesses)
                    process.AdjustPriority(false);
 
                if (!byondLock.SupportsCli)
                    networkPromptReaper.RegisterProcess(process);
 
                // If this isnt a staging DD (From a Deployment), fire off an event
                if (!apiValidate)
                    await eventConsumer.HandleEvent(
                        EventType.DreamDaemonLaunch,
                        new List<string>
                        {
                            process.Id.ToString(CultureInfo.InvariantCulture),
                        },
                        false,
                        cancellationToken);
 
                return process;
            }
            catch
            {
                await using (process)
                {
                    process.Terminate();
                    await process.Lifetime;
                    throw;
                }
            }
        }
 
        async Task LogDDOutput(IProcess process, string outputFilePath, bool cliSupported, bool preserveFile, CancellationToken cancellationToken)
        {
            try
            {
                string ddOutput = null;
                if (cliSupported)
                    ddOutput = await process.GetCombinedOutput(cancellationToken);
 
                if (ddOutput == null)
                    try
                    {
                        var dreamDaemonLogBytes = await gameIOManager.ReadAllBytes(
                            outputFilePath,
                            cancellationToken);
 
                        ddOutput = Encoding.UTF8.GetString(dreamDaemonLogBytes);
                    }
                    finally
                    {
                        if (!preserveFile)
                            try
                            {
                                logger.LogTrace("Deleting temporary log file {path}...", outputFilePath);
                                await gameIOManager.DeleteFile(outputFilePath, cancellationToken);
                            }
                            catch (Exception ex)
                            {
                                logger.LogWarning(ex, "Failed to delete DreamDaemon log file {outputFilePath}!", outputFilePath);
                            }
                    }
 
                logger.LogTrace(
                    "DreamDaemon Output:{newLine}{output}",
                    Environment.NewLine,
                    ddOutput);
            }
            catch (Exception ex)
            {
                logger.LogWarning(ex, "Error reading DreamDaemon output!");
            }
        }
 
        RuntimeInformation CreateRuntimeInformation(
            IDmbProvider dmbProvider,
            IChatTrackingContext chatTrackingContext,
            DreamDaemonLaunchParameters launchParameters,
            bool apiValidateOnly)
            => new (
                chatTrackingContext,
                dmbProvider,
                assemblyInformationProvider.Version,
                instance.Name,
                launchParameters?.SecurityLevel,
                launchParameters?.Visibility,
                serverPortProvider.HttpApiPort,
                apiValidateOnly);
 
        async Task CheckPagerIsNotRunning(CancellationToken cancellationToken)
        {
            if (!platformIdentifier.IsWindows)
                return;
 
            await using var otherProcess = processExecutor.GetProcessByName("byond");
            if (otherProcess == null)
                return;
 
            var otherUsernameTask = otherProcess.GetExecutingUsername(cancellationToken);
            await using var ourProcess = processExecutor.GetCurrentProcess();
            var ourUserName = await ourProcess.GetExecutingUsername(cancellationToken);
            var otherUserName = await otherUsernameTask;
 
            if (otherUserName.Equals(ourUserName, StringComparison.Ordinal))
                throw new JobException(ErrorCode.DeploymentPagerRunning);
        }
    }
}