PosixByondInstaller.cs

Go to the documentation of this file.

using System;
using System.Globalization;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Common.Extensions;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.IO;
 
namespace Tgstation.Server.Host.Components.Engine
{
    sealed class PosixByondInstaller : ByondInstallerBase
    {
        const string DreamDaemonExecutableName = "DreamDaemon";
 
        const string DreamMakerExecutableName = "DreamMaker";
 
        const string ShellScriptExtension = ".sh";
 
        protected override string PathToUserFolder { get; }
 
        protected override string DreamMakerName => DreamMakerExecutableName + ShellScriptExtension;
 
        protected override string OSMarkerTemplate => "Linux";
 
        readonly IPostWriteHandler postWriteHandler;
 
        public PosixByondInstaller(
            IPostWriteHandler postWriteHandler,
            IIOManager ioManager,
            IFileDownloader fileDownloader,
            IOptionsMonitor<GeneralConfiguration> generalConfigurationOptions,
            ILogger<PosixByondInstaller> logger)
            : base(ioManager, logger, fileDownloader, generalConfigurationOptions)
        {
            this.postWriteHandler = postWriteHandler ?? throw new ArgumentNullException(nameof(postWriteHandler));
 
            PathToUserFolder = IOManager.ResolvePath(
                IOManager.ConcatPath(
                    Environment.GetFolderPath(
                        Environment.SpecialFolder.UserProfile,
                        Environment.SpecialFolderOption.DoNotVerify),
                    "./.byond/cache"));
        }
 
        public override ValueTask UpgradeInstallation(EngineVersion version, string path, CancellationToken cancellationToken)
        {
            CheckVersionValidity(version);
            ArgumentNullException.ThrowIfNull(path);
 
            return ValueTask.CompletedTask;
        }
 
        public override ValueTask TrustDmbPath(EngineVersion version, string fullDmbPath, CancellationToken cancellationToken)
        {
            ArgumentNullException.ThrowIfNull(version);
            ArgumentNullException.ThrowIfNull(fullDmbPath);
 
            Logger.LogTrace("No need to trust .dmb path \"{path}\" on POSIX", fullDmbPath);
            return ValueTask.CompletedTask;
        }
 
        protected override ValueTask InstallImpl(EngineVersion version, string path, bool deploymentPipelineProcesses, CancellationToken cancellationToken)
        {
            // write the scripts for running the ting
            // need to add $ORIGIN to LD_LIBRARY_PATH
            const string StandardScript = "#!/bin/sh\nexport LD_LIBRARY_PATH=\"\\$ORIGIN:$LD_LIBRARY_PATH\"\nBASEDIR=$(dirname \"$0\")\nexec \"$BASEDIR/{0}\" \"$@\"\n";
 
            var dreamDaemonScript = String.Format(CultureInfo.InvariantCulture, StandardScript, DreamDaemonExecutableName);
            var dreamMakerScript = String.Format(CultureInfo.InvariantCulture, StandardScript, DreamMakerExecutableName);
 
            async ValueTask WriteAndMakeExecutable(string pathToScript, string script)
            {
                Logger.LogTrace("Writing script {path}:{newLine}{scriptContents}", pathToScript, Environment.NewLine, script);
                await IOManager.WriteAllBytes(pathToScript, Encoding.ASCII.GetBytes(script), cancellationToken);
                postWriteHandler.HandleWrite(IOManager.ResolvePath(pathToScript));
            }
 
            var basePath = IOManager.ConcatPath(path, ByondBinPath);
 
            var ddTask = WriteAndMakeExecutable(
                IOManager.ConcatPath(basePath, GetDreamDaemonName(version.Version!, out _)),
                dreamDaemonScript);
 
            var dmTask = WriteAndMakeExecutable(
                IOManager.ConcatPath(basePath, DreamMakerName),
                dreamMakerScript);
 
            var task = ValueTaskExtensions.WhenAll(
                ddTask,
                dmTask);
 
            postWriteHandler.HandleWrite(IOManager.ConcatPath(basePath, DreamDaemonExecutableName));
            postWriteHandler.HandleWrite(IOManager.ConcatPath(basePath, DreamMakerExecutableName));
 
            return task;
        }
 
        protected override string GetDreamDaemonName(Version byondVersion, out bool supportsCli)
        {
            supportsCli = true;
            return DreamDaemonExecutableName + ShellScriptExtension;
        }
    }
}