SimulationStatusMonitor.cs

Go to the documentation of this file.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Threading;
using RestSharp;
 
namespace AnalyzeRe.Utilities
{
    [Obsolete("This class has not been maintained in some time and " +
        "does not use the recommended exponential back-off polling mechanism. " +
        "Consider using the API.PollUntil() method.")]
    public class SimulationStatusMonitor
    {
        private const NumberStyles DoubleParseStyle = NumberStyles.AllowDecimalPoint;
        private static readonly CultureInfo ParseCulture = CultureInfo.InvariantCulture;
 
        #region Private Fields
        private readonly ConcurrentDictionary<string, SimulationStatus> _simulations;
        #endregion Private Fields
 
        #region Public Fields
        public double MaxPollInterval = 5.0;
        public int MaxTimeouts = 3;
        public int NumActivePolls => _numActivePolls;
        private int _numActivePolls = 0;
        public List<SimulationStatus> MonitoredSimulations => _simulations.Values.ToList();
        #endregion Public Fields
 
        #region Public Events
        public delegate void SimulationStatusAddedDelegate(SimulationStatusMonitor sender, SimulationStatus added);
        public SimulationStatusAddedDelegate SimulationStatusAdded;
 
        public delegate void SimulationStatusChangedDelegate(SimulationStatusMonitor sender, SimulationStatus changed);
        public SimulationStatusChangedDelegate SimulationStatusChanged;
        #endregion Public Events
 
        #region Constructor
        public SimulationStatusMonitor()
        {
            _simulations = new ConcurrentDictionary<string, SimulationStatus>();
        }
        #endregion Constructor
 
        #region Public Control Methods
        public void AbortAll()
        {
            foreach (SimulationStatus active in _simulations.Where(sim => sim.Value.BeingPolled)
                                                            .Select(kvp => kvp.Value))
            {
                active.BeingPolled = false;
                active.Exception = new Exception("Monitoring Cancelled.");
            }
        }
 
        public void Reset()
        {
            AbortAll();
            _simulations.Values.ToList().ForEach(sim =>
                sim.SimulationStatusChanged -= OnSimulationStatusChanged);
            _simulations.Clear();
        }
        #endregion Public Control Methods
 
        #region Event Monitoring
        public void MonitorSimulationRequest(IAPIResourceView view, Action simulationRequest)
        {
            // If this view has been monitored and its state is Complete, nothing to monitor, so return.
            // If its state is Running, or Queued, it's being monitored already, so return.
            // If its state is Error, however, we might wish to re-initiate monitoring (the error might have been resolved).
            if (_simulations.ContainsKey(view.id) && _simulations[view.id].State != SimulationStatus.SimulationState.Error)
                return;
            Thread t = new Thread(() => PollSimulationResultsUntilReady(this, view, simulationRequest, MaxPollInterval));
            t.Start();
        }
 
        private void OnSimulationStatusChanged(object sender, EventArgs e)
        {
            SimulationStatusChanged?.Invoke(this, sender as SimulationStatus);
        }
        #endregion Event Monitoring
 
        #region Threaded polling
        private static void PollSimulationResultsUntilReady(SimulationStatusMonitor owner, IAPIResourceView view, Action simulationRequest, double maxPollInterval)
        {
            SimulationStatus status = new SimulationStatus(view.id) { BeingPolled = true };
            bool added = owner._simulations.TryAdd(view.id, status);
            if (added)
            {
                status.Description = view is PortfolioView ? "Portfolio (" + ((PortfolioView)view).layer_views.Count + " layer" + (((PortfolioView)view).layer_views.Count > 1 ? "s)" : ")")
                    : view is ILayerView ? ((ILayerView)view).layer.type + " Layer" + (String.IsNullOrWhiteSpace(((ILayerView)view).layer.description) ? "" : " \"" + ((ILayerView)view).layer.description + "\"") : null;
                owner.SimulationStatusAdded?.Invoke(owner, status);
                status.SimulationStatusChanged += owner.OnSimulationStatusChanged;
            }
            else
            {   // Another thread is/was already polling this view's simulation.
                status = owner._simulations[view.id];
                // If it's still actively being polled, or already completed successfully, we don't need another polling thread.
                if (status.BeingPolled || status.State == SimulationStatus.SimulationState.Complete)
                    return;
                else
                {
                    status.BeingPolled = true; // Last polling must have failed, so poll this view again.
                    status.Exception = null;
                }
            }
 
            if (status.BeingPolled) status.State = SimulationStatus.SimulationState.Queued; // Narrow the race condition window, but it's not such an important one as to merit a lock.
            int timeouts = 0;
            Interlocked.Increment(ref owner._numActivePolls);
            while (status.BeingPolled) // Poll until the server responds successfully to the request, or we encounter a non-'503-ServiceUnavailable' error.
            {
                try
                {
                    simulationRequest();
                    // Success. Update some properties and quit the thread.
                    Interlocked.Decrement(ref owner._numActivePolls);
                    status.TimeRemaining = 0;
                    status.State = SimulationStatus.SimulationState.Complete;
                    status.BeingPolled = false;
                }
                catch (APIRequestException e)
                {
                    try
                    {
                        if (e.RestResponse == null ||
                            e.RestResponse.StatusCode != HttpStatusCode.ServiceUnavailable)
                            throw;
                        Parameter retryAfter = e.RestResponse.Headers.FirstOrDefault(header =>
                            header.Name.Equals("Retry-After", StringComparison.OrdinalIgnoreCase));
                        // Re-throw the original '503-Service Unavailable'. We won't poll since there's no Retry-After header.
                        if (retryAfter == null)
                            throw;
 
                        if (!Double.TryParse(retryAfter.Value.ToString(), DoubleParseStyle, ParseCulture, out double retryAfterSeconds))
                            throw new Exception("The server provided a Retry-After header, " +
                                "but it could not be parsed: " + retryAfter.Value, e);
 
                        status.TimeRemaining = retryAfterSeconds;
                        double nextSleep_seconds = Math.Min(maxPollInterval, retryAfterSeconds);
                        Thread.Sleep((int)(1000 * nextSleep_seconds));
                    }
                    catch (Exception ex)
                    {
                        Interlocked.Decrement(ref owner._numActivePolls);
                        status.Exception = ex;
                        status.BeingPolled = false;
                    }
                }
                catch (TimeoutException ex)
                {
                    timeouts++;
                    if (timeouts >= owner.MaxTimeouts)
                    {   // Too many timeouts, notify anyone monitoring of the error.
                        Interlocked.Decrement(ref owner._numActivePolls);
                        status.Exception = ex;
                        status.BeingPolled = false;
                    }
                }
                catch (Exception ex)
                {   // An unknown exception occurred. We cannot keep polling.
                    Interlocked.Decrement(ref owner._numActivePolls);
                    status.Exception = ex;
                    status.BeingPolled = false;
                }
            }
        }
        #endregion Threaded polling
    }
}