JobProgressReporter.cs

Go to the documentation of this file.

using System;
 
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Logging.Abstractions;
 
using Tgstation.Server.Host.Models;
 
namespace Tgstation.Server.Host.Jobs
{
    public sealed class JobProgressReporter : IDisposable
    {
        public string? StageName
        {
            get => stageName;
            set
            {
                if (stageName == value)
                    return;
 
                stageName = value;
                callback(stageName, lastProgress);
            }
        }
 
        readonly ILogger<JobProgressReporter> logger;
 
        readonly Action<string?, double?> callback;
 
        string? stageName;
 
        double? lastProgress;
 
        double sectionProgression;
 
        double? sectionReservations;
 
        public JobProgressReporter()
            : this(
                 NullLogger<JobProgressReporter>.Instance,
                 null,
                 (_, _) => { },
                 false)
        {
        }
 
        public JobProgressReporter(ILogger<JobProgressReporter> logger, string? stageName, Action<string?, double?> callback)
            : this(
                 logger,
                 stageName,
                 callback,
                 true)
        {
        }
 
        private JobProgressReporter(ILogger<JobProgressReporter> logger, string? stageName, Action<string?, double?> callback, bool setStageName)
        {
            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
            this.callback = callback ?? throw new ArgumentNullException(nameof(callback));
            if (setStageName)
            {
                StageName = stageName;
            }
            else
            {
                this.stageName = stageName;
            }
 
            logger.LogDebug("Job progress reporter created. Stage: {stageName}", stageName ?? "(null)");
        }
 
        public void Dispose()
        {
            if (sectionReservations.HasValue)
                if (sectionReservations.Value != 1.0)
                {
                    // not an error, processes can throw
                    sectionReservations = null;
                }
                else if (sectionProgression < 1.0)
                {
                    logger.LogError(
                        new InvalidOperationException($"Parent progress reporter has child sections that didn't complete! Current: {sectionProgression}"),
                        "TGS BUG: Progress reporter children didn't complete!");
                    sectionReservations = null;
                }
 
            if (!sectionReservations.HasValue)
                ReportProgress(1);
        }
 
        public void ReportProgress(double? progress)
        {
            if (sectionReservations.HasValue)
                if (progress == 0)
                {
                    // might be a stage reset
                    sectionReservations = null;
                }
                else
                {
                    logger.LogError(
                        new InvalidOperationException("Progress reporter is reporting progress with existing nested sections!"),
                        "TGS BUG: A progress reporter is using mixed local and nested progress, this is not supported");
                }
 
            var clampedProgress = progress;
            if (progress.HasValue)
                if (progress > 1 || progress < 0)
                {
                    logger.LogError(
                        new ArgumentOutOfRangeException(nameof(progress), progress, "Progress must be a value from 0-1!"),
                        "TGS BUG: Invalid progress value for stage {stageName}",
                        StageName ?? "(null)");
                    clampedProgress = null;
                }
                else
                    sectionProgression = progress.Value;
 
            callback(StageName, clampedProgress);
            lastProgress = clampedProgress;
        }
 
        public JobProgressReporter CreateSection(string? newStageName, double percentage)
        {
            if (percentage > 1 || percentage < 0)
            {
                logger.LogError(
                    new ArgumentOutOfRangeException(nameof(percentage), percentage, "Percentage must be a value from 0-1!"),
                    "TGS BUG: Invalid percentage value for stage {newStageName}! Clamping...",
                    newStageName ?? "(null)");
 
                percentage = Math.Min(Math.Max(percentage, 0.0), 1.0);
            }
 
            if (!sectionReservations.HasValue)
            {
                if (sectionProgression != 0)
                {
                    logger.LogError(
                        new InvalidOperationException("Progress reporter is creating a section with local progress!"),
                        "TGS BUG: A progress reporter is using mixed local and nested progress, this is not supported");
                }
 
                sectionReservations = 0;
            }
 
            // floating point >.<
            if (percentage + sectionReservations.Value > 1.0001)
            {
                var remainingPercentage = 1.0 - sectionReservations.Value;
                logger.LogError(
                    "Stage {newStageName} is overbudgeted ({budget}/{remainingPercentage})! Clamping...",
                    newStageName,
                    percentage,
                    remainingPercentage);
                percentage = remainingPercentage;
            }
 
            Math.Min(sectionReservations.Value + percentage, 1);
 
            var childLocalProgress = 0.0;
            var newReporter = new JobProgressReporter(
                logger,
                newStageName,
                (currentStage, progress) =>
                {
                    currentStage ??= StageName;
                    if (!progress.HasValue)
                    {
                        callback(currentStage, null);
                        return;
                    }
 
                    var progressWithoutChild = sectionProgression - childLocalProgress;
                    childLocalProgress = progress.Value * percentage;
 
                    // floating point >.<
                    sectionProgression = Math.Min(progressWithoutChild + childLocalProgress, 1);
                    if (sectionProgression > 9.9999)
                        sectionProgression = 1;
 
                    callback(currentStage, sectionProgression);
                },
                false);
 
            newReporter.ReportProgress(0);
            return newReporter;
        }
    }
}