OpenDreamInstallation.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Net.Mime;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Internal;
using Tgstation.Server.Common.Http;
using Tgstation.Server.Host.Components.Deployment;
using Tgstation.Server.Host.Components.Interop;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.System;
using Tgstation.Server.Host.Utils;
 
namespace Tgstation.Server.Host.Components.Engine
{
    sealed class OpenDreamInstallation : EngineInstallationBase
    {
        public override EngineVersion Version { get; }
 
        public override string ServerExePath { get; }
 
        public override string CompilerExePath { get; }
 
        public override bool PromptsForNetworkAccess => false;
 
        public override bool HasStandardOutput => true;
 
        public override bool PreferFileLogging => true;
 
        public override bool UseDotnetDump => true;
 
        public override Task InstallationTask { get; }
 
        readonly IAsyncDelayer asyncDelayer;
 
        readonly IAbstractHttpClientFactory httpClientFactory;
 
        readonly string serverDllPath;
 
        readonly string compilerDllPath;
 
        public OpenDreamInstallation(
            IIOManager installationIOManager,
            IAsyncDelayer asyncDelayer,
            IAbstractHttpClientFactory httpClientFactory,
            string dotnetPath,
            string serverDllPath,
            string compilerDllPath,
            Task installationTask,
            EngineVersion version)
            : base(installationIOManager)
        {
            this.asyncDelayer = asyncDelayer ?? throw new ArgumentNullException(nameof(asyncDelayer));
            this.httpClientFactory = httpClientFactory ?? throw new ArgumentNullException(nameof(httpClientFactory));
 
            ServerExePath = dotnetPath ?? throw new ArgumentNullException(nameof(dotnetPath));
            CompilerExePath = dotnetPath;
 
            this.serverDllPath = serverDllPath ?? throw new ArgumentNullException(nameof(serverDllPath));
            this.compilerDllPath = compilerDllPath ?? throw new ArgumentNullException(nameof(compilerDllPath));
            InstallationTask = installationTask ?? throw new ArgumentNullException(nameof(installationTask));
            Version = version ?? throw new ArgumentNullException(nameof(version));
 
            if (version.Engine!.Value != EngineType.OpenDream)
                throw new ArgumentException($"Invalid EngineType: {version.Engine.Value}", nameof(version));
        }
 
        public override string FormatServerArguments(
            IDmbProvider dmbProvider,
            IReadOnlyDictionary<string, string> parameters,
            DreamDaemonLaunchParameters launchParameters,
            string? logFilePath)
        {
            ArgumentNullException.ThrowIfNull(dmbProvider);
            ArgumentNullException.ThrowIfNull(parameters);
            ArgumentNullException.ThrowIfNull(launchParameters);
 
            if (!parameters.TryGetValue(DMApiConstants.ParamAccessIdentifier, out var accessIdentifier))
                throw new ArgumentException($"parameters must have \"{DMApiConstants.ParamAccessIdentifier}\" set!", nameof(parameters));
 
            var parametersString = EncodeParameters(parameters, launchParameters);
 
            var arguments = $"{serverDllPath} --cvar {(logFilePath != null ? $"log.path=\"{InstallationIOManager.GetDirectoryName(logFilePath)}\" --cvar log.format=\"{InstallationIOManager.GetFileName(logFilePath)}\"" : "log.enabled=false")} --cvar watchdog.token={accessIdentifier} --cvar log.runtimelog=false --cvar net.port={launchParameters.Port!.Value} --cvar opendream.topic_port={launchParameters.OpenDreamTopicPort!.Value} --cvar opendream.world_params=\"{parametersString}\" --cvar opendream.json_path=\"./{dmbProvider.DmbName}\"";
            return arguments;
        }
 
        public override string FormatCompilerArguments(string dmePath, string? additionalArguments)
        {
            if (String.IsNullOrWhiteSpace(additionalArguments))
                additionalArguments = String.Empty;
            else
                additionalArguments = $"{additionalArguments.Trim()} ";
 
            return $"{compilerDllPath} --suppress-unimplemented --notices-enabled {additionalArguments}\"{dmePath ?? throw new ArgumentNullException(nameof(dmePath))}\"";
        }
 
        public override async ValueTask StopServerProcess(
            ILogger logger,
            IProcess process,
            string accessIdentifier,
            ushort port,
            CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(logger);
 
            const int MaximumTerminationSeconds = 5;
 
            logger.LogTrace("Attempting Robust.Server graceful exit (Timeout: {seconds}s)...", MaximumTerminationSeconds);
            var timeout = asyncDelayer.Delay(TimeSpan.FromSeconds(MaximumTerminationSeconds), cancellationToken).AsTask();
            var lifetime = process.Lifetime;
            if (lifetime.IsCompleted)
                logger.LogTrace("Robust.Server already exited");
 
            var stopwatch = Stopwatch.StartNew();
            try
            {
                using var httpClient = httpClientFactory.CreateClient();
                using var request = new HttpRequestMessage();
                request.Headers.Add("WatchdogToken", accessIdentifier);
                request.RequestUri = new Uri($"http://localhost:{port}/shutdown");
                request.Content = new StringContent(
                    "{\"Reason\":\"TGS session termination\"}",
                    Encoding.UTF8,
                    new MediaTypeHeaderValue(MediaTypeNames.Application.Json));
                request.Method = HttpMethod.Post;
 
                var responseTask = httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
                try
                {
                    await Task.WhenAny(timeout, lifetime, responseTask);
                    if (responseTask.IsCompleted)
                    {
                        using var response = await responseTask;
                        if (response.IsSuccessStatusCode)
                        {
                            logger.LogDebug("Robust.Server responded to the shutdown command successfully ({requestMs}ms). Waiting for exit...", stopwatch.ElapsedMilliseconds);
                            await Task.WhenAny(timeout, lifetime);
                        }
                    }
 
                    if (!lifetime.IsCompleted)
                        logger.LogWarning("Robust.Server graceful exit timed out!");
                }
                catch (Exception ex) when (ex is not OperationCanceledException)
                {
                    logger.LogDebug(ex, "Unable to send graceful exit request to Robust.Server watchdog API!");
                }
 
                if (lifetime.IsCompleted)
                {
                    logger.LogTrace("Robust.Server exited without termination");
                    return;
                }
            }
            finally
            {
                logger.LogTrace("Robust.Server graceful shutdown attempt took {totalMs}ms", stopwatch.ElapsedMilliseconds);
            }
 
            await base.StopServerProcess(logger, process, accessIdentifier, port, cancellationToken);
        }
    }
}