ByondExecutableLock.cs

Go to the documentation of this file.

using System;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Tgstation.Server.Host.Core;
using Tgstation.Server.Host.IO;

namespace Tgstation.Server.Host.Components.Byond
{
    sealed class ByondExecutableLock : IByondExecutableLock
    {
        public Version Version { get; }

        public string DreamDaemonPath { get; }

        public string DreamMakerPath { get; }

        readonly IIOManager ioManager;

        readonly SemaphoreSlim trustedFileSemaphore;

        readonly string trustedFilePath;

        public ByondExecutableLock(
            IIOManager ioManager,
            SemaphoreSlim trustedFileSemaphore,
            Version version,
            string dreamDaemonPath,
            string dreamMakerPath,
            string trustedFilePath)
        {
            this.ioManager = ioManager ?? throw new ArgumentNullException(nameof(ioManager));
            this.trustedFileSemaphore = trustedFileSemaphore ?? throw new ArgumentNullException(nameof(trustedFileSemaphore));
            Version = version ?? throw new ArgumentNullException(nameof(version));
            DreamDaemonPath = dreamDaemonPath ?? throw new ArgumentNullException(nameof(dreamDaemonPath));
            DreamMakerPath = dreamMakerPath ?? throw new ArgumentNullException(nameof(dreamMakerPath));
            this.trustedFilePath = trustedFilePath ?? throw new ArgumentNullException(nameof(trustedFilePath));
        }

        // at one point in design, byond versions were to delete themselves if they weren't the active version
        // That changed at some point so these functions are intentioanlly left blank

        public void Dispose() { }

        public void DoNotDeleteThisSession() { }

        public async Task TrustDmbPath(string fullDmbPath, CancellationToken cancellationToken)
        {
            if (fullDmbPath == null)
                throw new ArgumentNullException(nameof(fullDmbPath));

            using (await SemaphoreSlimContext.Lock(trustedFileSemaphore, cancellationToken).ConfigureAwait(false))
            {
                string trustedFileText;

                if (await ioManager.FileExists(trustedFilePath, cancellationToken).ConfigureAwait(false))
                {
                    var trustedFileBytes = await ioManager.ReadAllBytes(trustedFilePath, cancellationToken).ConfigureAwait(false);
                    trustedFileText = Encoding.UTF8.GetString(trustedFileBytes);
                    trustedFileText = $"{trustedFileText.Trim()}{Environment.NewLine}";
                }
                else
                {
                    trustedFileText = String.Empty;
                }

                if (trustedFileText.Contains(fullDmbPath, StringComparison.Ordinal))
                    return;

                trustedFileText = $"{trustedFileText}{fullDmbPath}{Environment.NewLine}";

                var newTrustedFileBytes = Encoding.UTF8.GetBytes(trustedFileText);
                await ioManager.WriteAllBytes(trustedFilePath, newTrustedFileBytes, cancellationToken).ConfigureAwait(false);
            }
        }
    }
}