ScheduledAction.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Persistence;
using Waher.Persistence.Attributes;
using Waher.Persistence.Filters;
using Waher.Runtime.Profiling;
using Waher.Runtime.Threading;
using Waher.Script;
using Waher.Service.IoTBroker.StateMachines.Exceptions;
 
namespace Waher.Service.IoTBroker.StateMachines.Model.Actions.Runtime
{
    [CollectionName("ScheduledActions")]
    [Index("Timepoint", "StateMachineId", "Action")]
    [Index("StateMachineId", "Timepoint", "Action")]
    public class ScheduledAction
    {
        public ScheduledAction()
            : base()
        {
        }
 
        [ObjectId]
        public string ObjectId { get; set; }
 
        public CaseInsensitiveString StateMachineId { get; set; }
 
        public DateTime Timepoint { get; set; }
 
        public string Action { get; set; }
 
        public string BeforeActionScript { get; set; }
 
        internal static async Task Schedule(CaseInsensitiveString StateMachineId, 
            DateTime Timepoint, string Action, string BeforeActionScript)
        {
            ScheduledAction Result = new ScheduledAction()
            {
                StateMachineId = StateMachineId,
                Timepoint = Timepoint,
                Action = Action,
                BeforeActionScript = BeforeActionScript
            };
 
            await Database.Insert(Result);
 
            if (nextAction is null || Result.Timepoint < nextAction.Timepoint)
            {
                if (nextActionTimer != DateTime.MinValue)
                {
                    Gateway.CancelScheduledEvent(nextActionTimer);
                    nextActionTimer = DateTime.MinValue;
                }
 
                nextAction = Result;
                nextActionTimer = Gateway.ScheduleEvent(ExecutePendingActions, nextAction.Timepoint, null);
            }
        }
 
        private static async Task<IEnumerable<ScheduledAction>> GetElapsedActions(int MaxCount)
        {
            return await Database.Find<ScheduledAction>(0, MaxCount,
                new FilterFieldLesserOrEqualTo("Timepoint", DateTime.UtcNow));
        }
 
        internal static async Task DeleteScheduledActions(CaseInsensitiveString StateMachineId)
        {
            await Database.Delete<ScheduledAction>(
                new FilterFieldLesserOrEqualTo("StateMachineId", StateMachineId));
        }
 
        internal static async Task ScheduleNext()
        {
            try
            {
                if (nextActionTimer != DateTime.MinValue)
                {
                    Gateway.CancelScheduledEvent(nextActionTimer);
                    nextActionTimer = DateTime.MinValue;
                }
 
                nextAction = await Database.FindFirstIgnoreRest<ScheduledAction>("Timepoint");
                if (nextAction is null)
                    return;
 
                nextActionTimer = Gateway.ScheduleEvent(ExecutePendingActions, nextAction.Timepoint, null);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        internal static async Task ExecutePendingActions(object _)
        {
            nextActionTimer = DateTime.MinValue;
 
            try
            {
                const int N = 1000;
                int n;
 
                do
                {
                    IEnumerable<ScheduledAction> Actions = await GetElapsedActions(N);
                    n = 0;
 
                    foreach (ScheduledAction Action in Actions)
                    {
                        n++;
 
                        try
                        {
                            using Semaphore Semaphore = await Semaphores.BeginWrite("machine:" + Action.StateMachineId.Value);
                            StateMachineProcessor.CacheRecord Rec = await StateMachineProcessor.GetStateMachine(Action.StateMachineId, true);
                            StateMachine Machine = Rec?.Machine;
 
                            if (!(Machine is null))
                            {
                                if (!Machine.TryGetAction(Action.Action, out Action Action2))
                                    throw new StateMachineException(Rec.Machine, "Action '" + Action.Action + "' not found in state machine.");
 
                                Variables Variables = Rec.CurrentState.GetVariables(Machine);
                                EvaluationArguments Arguments = new EvaluationArguments(Variables,
                                    Machine, null, Rec.CurrentState, Rec.Legal, Rec.EDaler,
                                    Rec.Profiler);
 
                                ProfilerThread Thread = Arguments.Profiler?.GetThread(Action.Action, ProfilerThreadType.Binary);
                                Thread?.High();
 
                                try
                                {
                                    if (!string.IsNullOrEmpty(Action.BeforeActionScript))
                                        await Expression.EvalAsync(Action.BeforeActionScript, Variables);
 
                                    await Action2.Execute(Arguments);
                                }
                                finally
                                {
                                    Thread?.Low();
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Log.Exception(ex);
                        }
                        finally
                        {
                            await Database.Delete(Action);
                        }
                    }
                }
                while (n == N);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
            finally
            {
                await ScheduleNext();
            }
        }
 
        private static ScheduledAction nextAction = null;
        private static DateTime nextActionTimer = DateTime.MinValue;
    }
}