EngineInstallationBase.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web;
 
using DotEnv.Core;
 
using Microsoft.Extensions.Logging;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Api.Models.Internal;
using Tgstation.Server.Host.Components.Deployment;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.System;
 
namespace Tgstation.Server.Host.Components.Engine
{
    abstract class EngineInstallationBase : IEngineInstallation
    {
        public abstract EngineVersion Version { get; }
 
        public abstract string ServerExePath { get; }
 
        public abstract string CompilerExePath { get; }
 
        public abstract bool HasStandardOutput { get; }
 
        public abstract bool PreferFileLogging { get; }
 
        public abstract bool PromptsForNetworkAccess { get; }
 
        public abstract bool UseDotnetDump { get; }
 
        public abstract Task InstallationTask { get; }
 
        protected IIOManager InstallationIOManager { get; }
 
        protected static string EncodeParameters(
            IReadOnlyDictionary<string, string>? parameters,
            DreamDaemonLaunchParameters launchParameters)
        {
            var parametersString = parameters != null
                ? $"{String.Join('&', parameters.Select(kvp => $"{HttpUtility.UrlEncode(kvp.Key)}={HttpUtility.UrlEncode(kvp.Value)}"))}&"
                : String.Empty;
 
            if (!String.IsNullOrEmpty(launchParameters.AdditionalParameters))
                parametersString += launchParameters.AdditionalParameters;
 
            return parametersString;
        }
 
        public EngineInstallationBase(IIOManager installationIOManager)
        {
            InstallationIOManager = installationIOManager ?? throw new ArgumentNullException(nameof(installationIOManager));
        }
 
        public abstract string FormatCompilerArguments(string dmePath, string? additionalArguments);
 
        public abstract string FormatServerArguments(
            IDmbProvider dmbProvider,
            IReadOnlyDictionary<string, string>? parameters,
            DreamDaemonLaunchParameters launchParameters,
            string accessIdentifier,
            string? logFilePath);
 
        public virtual async ValueTask StopServerProcess(ILogger logger, IProcess process, string accessIdentifier, ushort port, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(logger);
            cancellationToken.ThrowIfCancellationRequested();
            logger.LogTrace("Terminating engine server process...");
            process.Terminate();
            await process.Lifetime;
        }
 
        public async ValueTask<Dictionary<string, string>?> LoadEnv(ILogger logger, bool forCompiler, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(logger);
 
            var envFile = forCompiler
                ? "compiler.env"
                : "server.env";
 
            if (!await InstallationIOManager.FileExists(envFile, cancellationToken))
            {
                logger.LogTrace("No {envFile} present in engine installation {version}", envFile, Version);
                return null;
            }
 
            logger.LogDebug("Loading {envFile} for engine installation {version}...", envFile, Version);
 
            var fileBytes = await InstallationIOManager.ReadAllBytes(envFile, cancellationToken);
            var fileContents = Encoding.UTF8.GetString(fileBytes);
            var parser = new EnvParser();
 
            try
            {
                var variables = parser.Parse(fileContents);
 
                return variables.ToDictionary();
            }
            catch (Exception ex)
            {
                logger.LogWarning(ex, "Unable to parse {envFile}!", envFile);
                return null;
            }
        }
    }
}