DeploymentLockManager.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
 
using Microsoft.Extensions.Logging;
 
using Tgstation.Server.Host.Models;
 
namespace Tgstation.Server.Host.Components.Deployment
{
    sealed class DeploymentLockManager : IAsyncDisposable
    {
        public CompileJob CompileJob => dmbProvider.CompileJob;
 
        readonly ILogger logger;
 
        readonly IDmbProvider dmbProvider;
 
        readonly HashSet<DmbLock> locks;
 
        readonly DmbLock firstLock;
 
        public static DeploymentLockManager Create(IDmbProvider dmbProvider, ILogger logger, string initialLockReason, out IDmbProvider firstLock, [CallerFilePath] string? callerFile = null, [CallerLineNumber] int callerLine = default)
        {
            var manager = new DeploymentLockManager(dmbProvider, logger, initialLockReason, callerFile!, callerLine);
            firstLock = manager.firstLock;
            return manager;
        }
 
        static string GetFullLockDescriptor(DmbLock dmbLock) => $"{dmbLock.LockID} {dmbLock.Descriptor} (Created at {dmbLock.LockTime}){(dmbLock.KeptAlive ? " (RELEASED)" : String.Empty)}";
 
        DeploymentLockManager(IDmbProvider dmbProvider, ILogger logger, string initialLockReason, string callerFile, int callerLine)
        {
            this.dmbProvider = dmbProvider ?? throw new ArgumentNullException(nameof(dmbProvider));
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
            logger.LogTrace("Initializing lock manager for compile job {id}", dmbProvider.CompileJob.Id);
            locks = new HashSet<DmbLock>();
            firstLock = CreateLock(initialLockReason, callerFile, callerLine);
        }
 
        public ValueTask DisposeAsync()
            => firstLock.DisposeAsync();
 
        public IDmbProvider AddLock(string reason, [CallerFilePath] string? callerFile = null, [CallerLineNumber]int callerLine = default)
        {
            ArgumentNullException.ThrowIfNull(reason);
            lock (locks)
            {
                if (locks.Count == 0)
                    throw new InvalidOperationException($"No locks exist on the DmbProvider for CompileJob {dmbProvider.CompileJob.Id}!");
 
                return CreateLock(reason, callerFile!, callerLine);
            }
        }
 
        public void LogLockStats(StringBuilder stringBuilder)
        {
            ArgumentNullException.ThrowIfNull(stringBuilder);
 
            stringBuilder.AppendLine(CultureInfo.InvariantCulture, $"Compile Job #{CompileJob.Id}: {CompileJob.DirectoryName}");
            lock (locks)
                foreach (var dmbLock in locks)
                    stringBuilder.AppendLine(CultureInfo.InvariantCulture, $"\t-{GetFullLockDescriptor(dmbLock)}");
        }
 
        DmbLock CreateLock(string reason, string callerFile, int callerLine)
        {
            DmbLock? newLock = null;
            string? descriptor = null;
            ValueTask LockCleanupAction()
            {
                ValueTask disposeTask = ValueTask.CompletedTask;
                lock (locks)
                {
                    logger.LogTrace("Removing .dmb Lock: {descriptor}", descriptor);
 
                    if (locks.Remove(newLock!))
                        logger.LogTrace("Lock was removed from list successfully");
                    else
                        logger.LogError("A .dmb lock was disposed more than once: {descriptor}", descriptor);
 
                    if (locks.Count == 0)
                        disposeTask = dmbProvider.DisposeAsync();
                    else if (newLock == firstLock)
                        logger.LogDebug("First lock on CompileJob #{compileJobId} removed, it must cleanup {remaining} remaining locks to be cleaned", CompileJob.Id, locks.Count);
                }
 
                return disposeTask;
            }
 
            newLock = new DmbLock(LockCleanupAction, dmbProvider, $"{callerFile}#{callerLine}: {reason}");
            locks.Add(newLock);
 
            descriptor = GetFullLockDescriptor(newLock!);
            logger.LogTrace("Created .dmb Lock: {descriptor}", descriptor);
 
            return newLock;
        }
    }
}