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 Tgstation.Server.Api.Models;
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 abstract string PathToUserFolder { get; }
 
        protected abstract string DreamMakerName { get; }
 
        protected abstract string ByondRevisionsUrlTemplate { get; }
 
        readonly IFileDownloader fileDownloader;
 
        protected ByondInstallerBase(IIOManager ioManager, ILogger<ByondInstallerBase> logger, IFileDownloader fileDownloader)
            : base(ioManager, logger)
        {
            this.fileDownloader = fileDownloader ?? throw new ArgumentNullException(nameof(fileDownloader));
        }
 
        public override IEngineInstallation CreateInstallation(EngineVersion version, string path, Task installationTask)
        {
            CheckVersionValidity(version);
 
            var installationIOManager = new ResolvingIOManager(IOManager, path);
            var supportsMapThreads = version.Version >= MapThreadsVersion;
 
            return new ByondInstallation(
                installationIOManager,
                installationTask,
                version,
                installationIOManager.ResolvePath(
                    installationIOManager.ConcatPath(
                        ByondBinPath,
                        GetDreamDaemonName(
                            version.Version!,
                            out var supportsCli))),
                installationIOManager.ResolvePath(
                    installationIOManager.ConcatPath(
                        ByondBinPath,
                        DreamMakerName)),
                supportsCli,
                supportsMapThreads);
        }
 
        public 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 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 url = String.Format(CultureInfo.InvariantCulture, ByondRevisionsUrlTemplate, version.Version!.Major, version.Version.Minor);
            return new Uri(url);
        }
    }
}