SessionControllerFactory.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Prometheus;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Internal;
using Tgstation.Server.Common.Extensions;
using Tgstation.Server.Host.Components.Chat;
using Tgstation.Server.Host.Components.Deployment;
using Tgstation.Server.Host.Components.Engine;
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 IEngineManager engineManager;
 
        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 IJobManager jobManager;
 
        readonly IDreamMaker dreamMaker;
 
        readonly IAsyncDelayer asyncDelayer;
 
        readonly IDotnetDumpService dotnetDumpService;
 
        readonly ILoggerFactory loggerFactory;
 
        readonly IOptionsMonitor<SessionConfiguration> sessionConfigurationOptions;
 
        readonly ILogger<SessionControllerFactory> logger;
 
        readonly Counter sessionsLaunched;
 
        readonly Gauge lastSessionLaunch;
 
        readonly Api.Models.Instance instance;
 
        async ValueTask PortBindTest(ushort port, EngineType engineType, CancellationToken cancellationToken)
        {
            logger.LogTrace("Bind test: {port}", port);
            try
            {
                // GIVE ME THE FUCKING PORT BACK WINDOWS!!!!
                const int MaxAttempts = 5;
                for (var i = 0; i < MaxAttempts; ++i)
                    try
                    {
                        SocketExtensions.BindTest(platformIdentifier, port, false, engineType == EngineType.OpenDream);
                        if (i > 0)
                            logger.LogDebug("Clearing the socket took {iterations} attempts :/", i + 1);
 
                        break;
                    }
                    catch (SocketException ex) when (platformIdentifier.IsWindows && ex.SocketErrorCode == SocketError.AddressAlreadyInUse && i < (MaxAttempts - 1))
                    {
                        await asyncDelayer.Delay(TimeSpan.FromSeconds(1), cancellationToken);
                    }
            }
            catch (SocketException ex) when (ex.SocketErrorCode == SocketError.AddressAlreadyInUse)
            {
                throw new JobException(ErrorCode.GameServerPortInUse, ex);
            }
        }
 
        public SessionControllerFactory(
            IProcessExecutor processExecutor,
            IEngineManager engineManager,
            ITopicClientFactory topicClientFactory,
            ICryptographySuite cryptographySuite,
            IAssemblyInformationProvider assemblyInformationProvider,
            IIOManager gameIOManager,
            IIOManager diagnosticsIOManager,
            IChatManager chat,
            INetworkPromptReaper networkPromptReaper,
            IPlatformIdentifier platformIdentifier,
            IBridgeRegistrar bridgeRegistrar,
            IServerPortProvider serverPortProvider,
            IEventConsumer eventConsumer,
            IJobManager jobManager,
            IDreamMaker dreamMaker,
            IAsyncDelayer asyncDelayer,
            IDotnetDumpService dotnetDumpService,
            IMetricFactory metricFactory,
            ILoggerFactory loggerFactory,
            IOptionsMonitor<SessionConfiguration> sessionConfigurationOptions,
            ILogger<SessionControllerFactory> logger,
            Api.Models.Instance instance)
        {
            this.processExecutor = processExecutor ?? throw new ArgumentNullException(nameof(processExecutor));
            this.engineManager = engineManager ?? throw new ArgumentNullException(nameof(engineManager));
            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.jobManager = jobManager ?? throw new ArgumentNullException(nameof(jobManager));
            this.dreamMaker = dreamMaker ?? throw new ArgumentNullException(nameof(dreamMaker));
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            this.dotnetDumpService = dotnetDumpService ?? throw new ArgumentNullException(nameof(dotnetDumpService));
            ArgumentNullException.ThrowIfNull(metricFactory);
            this.sessionConfigurationOptions = sessionConfigurationOptions ?? throw new ArgumentNullException(nameof(sessionConfigurationOptions));
            this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
            this.instance = instance ?? throw new ArgumentNullException(nameof(instance));
 
            sessionsLaunched = metricFactory.CreateCounter("tgs_sessions_launched", "The number of game server processes created");
            lastSessionLaunch = metricFactory.CreateGauge("tgs_session_start_time", "The UTC unix timestamp the most recent session was started");
        }
 
#pragma warning disable CA1506 // TODO: Decomplexify
        public async ValueTask<ISessionController> LaunchNew(
            IDmbProvider dmbProvider,
            IEngineExecutableLock? 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 engineLock = currentByondLock ?? await engineManager.UseExecutables(
                dmbProvider.EngineVersion,
                gameIOManager.ConcatPath(dmbProvider.Directory, dmbProvider.DmbName),
                cancellationToken);
            try
            {
                logger.LogDebug(
                    "Launching session with CompileJob {compileJobId}...",
                    dmbProvider.CompileJob.Id);
 
                // mad this isn't abstracted but whatever
                var engineType = dmbProvider.EngineVersion.Engine!.Value;
                if (engineType == EngineType.Byond)
                    await CheckPagerIsNotRunning();
 
                await PortBindTest(launchParameters.Port.Value, engineType, cancellationToken);
 
                string? outputFilePath = null;
                var preserveLogFile = true;
 
                var hasStandardOutput = engineLock.HasStandardOutput;
                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,
                            $"server-utc-{now.ToString("yyyy-MM-dd-HH-mm-ss", CultureInfo.InvariantCulture)}{(apiValidate ? "-dmapi" : String.Empty)}.log"));
 
                    logger.LogInformation("Logging server output to {path}...", outputFilePath);
                }
                else if (!hasStandardOutput)
                {
                    outputFilePath = gameIOManager.ConcatPath(dmbProvider.Directory, $"{Guid.NewGuid()}.server.log");
                    preserveLogFile = false;
                }
 
                var accessIdentifier = cryptographySuite.GetSecureString();
 
                if (!apiValidate && dmbProvider.CompileJob.DMApiVersion == null)
                    logger.LogDebug("Session will have no DMAPI support!");
 
                // launch dd
                var process = await CreateGameServerProcess(
                    dmbProvider,
                    engineLock,
                    launchParameters,
                    accessIdentifier,
                    outputFilePath,
                    apiValidate,
                    cancellationToken);
 
                try
                {
                    var chatTrackingContext = chat.CreateTrackingContext();
 
                    try
                    {
                        var runtimeInformation = CreateRuntimeInformation(
                            dmbProvider,
                            chatTrackingContext,
                            launchParameters.SecurityLevel!.Value,
                            launchParameters.Visibility!.Value,
                            apiValidate);
 
                        var reattachInformation = new ReattachInformation(
                            dmbProvider,
                            process,
                            runtimeInformation,
                            accessIdentifier,
                            launchParameters.Port.Value);
 
                        var byondTopicSender = topicClientFactory.CreateTopicClient(
                            TimeSpan.FromMilliseconds(
                                launchParameters.TopicRequestTimeout!.Value));
 
                        var sessionController = new SessionController(
                            reattachInformation,
                            instance,
                            process,
                            engineLock,
                            byondTopicSender,
                            chatTrackingContext,
                            bridgeRegistrar,
                            chat,
                            assemblyInformationProvider,
                            asyncDelayer,
                            dotnetDumpService,
                            eventConsumer,
                            jobManager,
                            dreamMaker,
                            loggerFactory.CreateLogger<SessionController>(),
                            () => LogDDOutput(
                                process,
                                outputFilePath,
                                hasStandardOutput,
                                preserveLogFile,
                                CancellationToken.None), // DCT: None available
                            launchParameters.StartupTimeout,
                            false,
                            apiValidate);
 
                        if (!apiValidate)
                        {
                            sessionsLaunched.Inc();
                            lastSessionLaunch.SetToCurrentTimeUtc();
                        }
 
                        return sessionController;
                    }
                    catch
                    {
                        chatTrackingContext.Dispose();
                        throw;
                    }
                }
                catch
                {
                    await using (process)
                    {
                        process.Terminate();
                        await process.Lifetime;
                        throw;
                    }
                }
            }
            catch
            {
                if (currentByondLock == null)
                    engineLock.Dispose();
                throw;
            }
        }
#pragma warning restore CA1506
 
        public async ValueTask<ISessionController?> Reattach(
            ReattachInformation reattachInformation,
            CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(reattachInformation);
 
            logger.LogTrace("Begin session reattach...");
            var byondTopicSender = topicClientFactory.CreateTopicClient(reattachInformation.TopicRequestTimeout);
            var engineLock = await engineManager.UseExecutables(
                reattachInformation.Dmb.EngineVersion,
                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 (engineLock.PromptsForNetworkAccess)
                        networkPromptReaper.RegisterProcess(process);
 
                    var chatTrackingContext = chat.CreateTrackingContext();
                    try
                    {
                        var runtimeInformation = CreateRuntimeInformation(
                            reattachInformation.Dmb,
                            chatTrackingContext,
                            reattachInformation.LaunchSecurityLevel,
                            reattachInformation.LaunchVisibility,
                            false);
                        reattachInformation.SetRuntimeInformation(runtimeInformation);
 
                        var controller = new SessionController(
                            reattachInformation,
                            instance,
                            process,
                            engineLock,
                            byondTopicSender,
                            chatTrackingContext,
                            bridgeRegistrar,
                            chat,
                            assemblyInformationProvider,
                            asyncDelayer,
                            dotnetDumpService,
                            eventConsumer,
                            jobManager,
                            dreamMaker,
                            loggerFactory.CreateLogger<SessionController>(),
                            () => ValueTask.CompletedTask,
                            null,
                            true,
                            false);
 
                        process = null;
                        engineLock = null;
                        chatTrackingContext = null;
 
                        return controller;
                    }
                    catch
                    {
                        chatTrackingContext?.Dispose();
                        throw;
                    }
                }
                catch
                {
                    if (process != null)
                        await process.DisposeAsync();
 
                    throw;
                }
            }
            catch
            {
                engineLock?.Dispose();
                throw;
            }
        }
 
        async ValueTask<IProcess> CreateGameServerProcess(
            IDmbProvider dmbProvider,
            IEngineExecutableLock engineLock,
            DreamDaemonLaunchParameters launchParameters,
            string accessIdentifier,
            string? logFilePath,
            bool apiValidate,
            CancellationToken cancellationToken)
        {
            var serverMayHaveDMApi = apiValidate || dmbProvider.CompileJob.DMApiVersion != null;
 
            var serverArguments = serverMayHaveDMApi
                ? new Dictionary<string, string>
                {
                    { DMApiConstants.ParamApiVersion, DMApiConstants.InteropVersion.Semver().ToString() },
                    { DMApiConstants.ParamServerPort, serverPortProvider.HttpApiPort.ToString(CultureInfo.InvariantCulture) },
                    { DMApiConstants.ParamAccessIdentifier, accessIdentifier },
                }
                : null;
 
            var environment = await engineLock.LoadEnv(logger, false, cancellationToken);
            var arguments = engineLock.FormatServerArguments(
                dmbProvider,
                serverArguments,
                launchParameters,
                accessIdentifier,
                !engineLock.HasStandardOutput || engineLock.PreferFileLogging
                    ? logFilePath
                    : null);
 
            // If this isnt a staging DD (From a Deployment), fire off events
            if (!apiValidate)
                await eventConsumer.HandleEvent(
                    EventType.DreamDaemonPreLaunch,
                    Enumerable.Empty<string?>(),
                    false,
                    false,
                    cancellationToken);
 
            var process = await processExecutor.LaunchProcess(
                engineLock.ServerExePath,
                dmbProvider.Directory,
                arguments,
                cancellationToken,
                environment,
                logFilePath,
                engineLock.HasStandardOutput,
                true);
 
            try
            {
                var sessionConfiguration = sessionConfigurationOptions.CurrentValue;
                if (!apiValidate)
                {
                    if (sessionConfiguration.HighPriorityLiveDreamDaemon)
                        process.AdjustPriority(true);
                }
                else if (sessionConfiguration.LowPriorityDeploymentProcesses)
                    process.AdjustPriority(false);
 
                if (!engineLock.HasStandardOutput)
                    networkPromptReaper.RegisterProcess(process);
 
                if (!apiValidate)
                    await eventConsumer.HandleEvent(
                        EventType.DreamDaemonLaunch,
                        new List<string>
                        {
                            process.Id.ToString(CultureInfo.InvariantCulture),
                        },
                        false,
                        false,
                        cancellationToken);
 
                return process;
            }
            catch
            {
                await using (process)
                {
                    process.Terminate();
                    await process.Lifetime;
                    throw;
                }
            }
        }
 
        async ValueTask LogDDOutput(IProcess process, string? outputFilePath, bool cliSupported, bool preserveFile, CancellationToken cancellationToken)
        {
            try
            {
                string? ddOutput = null;
                if (cliSupported)
                    ddOutput = (await process.GetCombinedOutput(cancellationToken))!;
 
                if (String.IsNullOrWhiteSpace(ddOutput) && outputFilePath != 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)
                            {
                                // this is expected on OD at time of the support changes.
                                // I've open a change to fix it: https://github.com/space-wizards/RobustToolbox/pull/4501
                                logger.LogWarning(ex, "Failed to delete server log file {outputFilePath}!", outputFilePath);
                            }
                    }
 
                logger.LogTrace(
                    "Server Output:{newLine}{output}",
                    Environment.NewLine,
                    ddOutput);
            }
            catch (Exception ex)
            {
                logger.LogWarning(ex, "Error reading server output!");
            }
        }
 
        RuntimeInformation CreateRuntimeInformation(
            IDmbProvider dmbProvider,
            IChatTrackingContext chatTrackingContext,
            DreamDaemonSecurity securityLevel,
            DreamDaemonVisibility visibility,
            bool apiValidateOnly)
            => new(
                chatTrackingContext,
                dmbProvider,
                assemblyInformationProvider.Version,
                instance.Name!,
                securityLevel,
                visibility,
                serverPortProvider.HttpApiPort,
                apiValidateOnly);
 
        async ValueTask CheckPagerIsNotRunning()
        {
            if (!platformIdentifier.IsWindows)
                return;
 
            await using var otherProcess = processExecutor.GetProcessByName("byond");
            if (otherProcess == null)
                return;
 
            var otherUsername = otherProcess.GetExecutingUsername();
 
            await using var ourProcess = processExecutor.GetCurrentProcess();
            var ourUsername = ourProcess.GetExecutingUsername();
 
            if (otherUsername.Equals(ourUsername, StringComparison.Ordinal))
                throw new JobException(ErrorCode.DreamDaemonPagerRunning);
        }
    }
}