ByondInstallerBase.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
 
using Tgstation.Server.Api.Models;
using Tgstation.Server.Host.Configuration;
using Tgstation.Server.Host.IO;
using Tgstation.Server.Host.Jobs;
 
namespace Tgstation.Server.Host.Components.Engine
{
    abstract class ByondInstallerBase : EngineInstallerBase
    {
        protected const string ByondBinPath = "byond/bin";
 
        protected const string CfgDirectoryName = "cfg";
 
        const string CacheDirectoryName = "cache";
 
        static readonly Version MapThreadsVersion = new(515, 1609);
 
        protected override EngineType TargetEngineType => EngineType.Byond;
 
        protected IOptionsMonitor<GeneralConfiguration> GeneralConfigurationOptions { get; }
 
        protected abstract string PathToUserFolder { get; }
 
        protected abstract string DreamMakerName { get; }
 
        protected abstract string OSMarkerTemplate { get; }
 
        readonly IFileDownloader fileDownloader;
 
        internal static Uri GetDownloadZipUrl(Version semver, string byondZipDownloadTemplate, string osMarkerTemplate)
        {
            // god forbid
            var guardGuid = Guid.NewGuid();
 
            var url = byondZipDownloadTemplate
                .Replace("$$", guardGuid.ToString(), StringComparison.Ordinal)
                .Replace("${Major}", semver.Major.ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal)
                .Replace("${Minor}", semver.Minor.ToString(CultureInfo.InvariantCulture), StringComparison.Ordinal);
 
            var osMarkerPrefix = $"${{{osMarkerTemplate}:";
            var osMarkerIndex = url.IndexOf(osMarkerPrefix);
            while (osMarkerIndex != -1)
            {
                var start = osMarkerIndex + osMarkerPrefix.Length;
                var end = url.IndexOf('}', start);
                if (end == -1)
                    break;
 
                var substitution = url.Substring(start, end - start);
                url = url.Replace($"{osMarkerPrefix}{substitution}}}", substitution, StringComparison.Ordinal);
 
                osMarkerIndex = url.IndexOf(osMarkerPrefix);
            }
 
            // at this point, any other substitution attempts should be removed
            var otherMarkerPrefix = "${";
            var otherMarkerIndex = url.IndexOf(otherMarkerPrefix);
            while (otherMarkerIndex != -1)
            {
                var start = otherMarkerIndex + otherMarkerPrefix.Length;
                var end = url.IndexOf('}', start);
                if (end == -1)
                    break;
 
                var substitution = url.Substring(start, end - start);
                url = url.Replace($"{otherMarkerPrefix}{substitution}}}", String.Empty, StringComparison.Ordinal);
 
                otherMarkerIndex = url.IndexOf(otherMarkerPrefix);
            }
 
            url = url.Replace(guardGuid.ToString(), "$", StringComparison.Ordinal);
 
            return new Uri(url);
        }
 
        protected ByondInstallerBase(
            IIOManager ioManager,
            ILogger<ByondInstallerBase> logger,
            IFileDownloader fileDownloader,
            IOptionsMonitor<GeneralConfiguration> generalConfigurationOptions)
            : base(ioManager, logger)
        {
            this.fileDownloader = fileDownloader ?? throw new ArgumentNullException(nameof(fileDownloader));
            GeneralConfigurationOptions = generalConfigurationOptions ?? throw new ArgumentNullException(nameof(generalConfigurationOptions));
        }
 
        public sealed override ValueTask<IEngineInstallation> GetInstallation(EngineVersion version, string path, Task installationTask, CancellationToken cancellationToken)
        {
            CheckVersionValidity(version);
 
            var installationIOManager = IOManager.CreateResolverForSubdirectory(path);
            var supportsMapThreads = version.Version >= MapThreadsVersion;
 
            var dreamDaemonName = GetDreamDaemonName(
                version.Version!,
                out var supportsCli);
            var dreamDaemonPath = installationIOManager.ResolvePath(
                installationIOManager.ConcatPath(
                    ByondBinPath,
                    dreamDaemonName));
            var dreamMakerPath = installationIOManager.ResolvePath(
                installationIOManager.ConcatPath(
                    ByondBinPath,
                    DreamMakerName));
 
            return ValueTask.FromResult<IEngineInstallation>(
                new ByondInstallation(
                    installationIOManager,
                    installationTask,
                    version,
                    dreamDaemonPath,
                    dreamMakerPath,
                    supportsCli,
                    supportsMapThreads));
        }
 
        public sealed override async Task CleanCache(CancellationToken cancellationToken)
        {
            try
            {
                var byondDir = PathToUserFolder;
 
                Logger.LogDebug("Cleaning BYOND cache...");
                async Task CleanDirectorySafe()
                {
                    try
                    {
                        await IOManager.DeleteDirectory(
                            IOManager.ConcatPath(
                                byondDir,
                                CacheDirectoryName),
                            cancellationToken);
                    }
                    catch (Exception ex)
                    {
                        Logger.LogWarning(ex, "Failed to clean BYOND cache!");
                    }
                }
 
                var cacheCleanTask = CleanDirectorySafe();
 
                // Create local cfg directory in case it doesn't exist
                var localCfgDirectory = IOManager.ConcatPath(
                    byondDir,
                    CfgDirectoryName);
 
                var cfgCreateTask = IOManager.CreateDirectory(
                    localCfgDirectory,
                    cancellationToken);
 
                var additionalCleanTasks = AdditionalCacheCleanFilePaths(localCfgDirectory)
                    .Select(path => IOManager.DeleteFile(path, cancellationToken));
 
                await Task.WhenAll(cacheCleanTask, cfgCreateTask, Task.WhenAll(additionalCleanTasks));
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                Logger.LogWarning(ex, "Error cleaning BYOND cache!");
            }
        }
 
        public sealed override async ValueTask<IEngineInstallationData> DownloadVersion(EngineVersion version, JobProgressReporter progressReporter, CancellationToken cancellationToken)
        {
            CheckVersionValidity(version);
 
            var url = GetDownloadZipUrl(version);
            Logger.LogTrace("Downloading {engineType} version {version} from {url}...", TargetEngineType, version, url);
 
            await using var download = fileDownloader.DownloadFile(url, null);
            await using var buffer = new BufferedFileStreamProvider(
                await download.GetResult(cancellationToken));
 
            var stream = await buffer.GetOwnedResult(cancellationToken);
            try
            {
                return new ZipStreamEngineInstallationData(
                    IOManager,
                    stream);
            }
            catch
            {
                await stream.DisposeAsync();
                throw;
            }
        }
 
        protected abstract string GetDreamDaemonName(Version byondVersion, out bool supportsCli);
 
        protected virtual IEnumerable<string> AdditionalCacheCleanFilePaths(string configDirectory) => Enumerable.Empty<string>();
 
        Uri GetDownloadZipUrl(EngineVersion version)
        {
            CheckVersionValidity(version);
 
            var guardGuid = Guid.NewGuid();
 
            var semver = version.Version!;
            var template = GeneralConfigurationOptions.CurrentValue.ByondZipDownloadTemplate;
            return GetDownloadZipUrl(semver, template, OSMarkerTemplate);
        }
    }
}