ProcessorSource.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Events;
using Waher.Persistence;
using Waher.Persistence.Filters;
using Waher.Processors.NodeTypes;
using Waher.Runtime.Language;
using Waher.Runtime.Settings;
using Waher.Things;
using Waher.Things.SourceEvents;
 
namespace Waher.Processors
{
    public class ProcessorSource : IDataSource
    {
        public const string SourceID = "Processors";
 
        private static readonly Dictionary<string, ProcessorNode> nodes = new Dictionary<string, ProcessorNode>();
        private static Root root = null;
        private static ProcessorSource instance = null;
 
        private DateTime lastChanged;
 
        public ProcessorSource()
        {
            this.lastChanged = RuntimeSettings.Get(SourceID + ".LastChanged", DateTime.MinValue);
            instance ??= this;
        }
 
        string IDataSource.SourceID => SourceID;
 
        public IEnumerable<IDataSource> ChildSources => null;
 
        public bool HasChildren => false;
 
        public DateTime LastChanged
        {
            get => this.lastChanged;
            internal set
            {
                if (this.lastChanged != value)
                {
                    this.lastChanged = value;
                    Task _ = RuntimeSettings.SetAsync("ProcessorSource.LastChanged", value);
                }
            }
        }
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ProcessorSource), 13, "Processors");
        }
 
        public async Task<INode> GetNodeAsync(IThingReference NodeRef)
        {
            return await GetNode(NodeRef);
        }
 
        public static Task<ProcessorNode> GetNode(string NodeId)
        {
            return GetNode(new ThingReference(NodeId, SourceID));
        }
 
        public static async Task<ProcessorNode> GetNode(IThingReference NodeRef)
        {
            if (NodeRef is null || NodeRef.SourceId != SourceID || !string.IsNullOrEmpty(NodeRef.Partition))
                return null;
 
            lock (nodes)
            {
                if (nodes.TryGetValue(NodeRef.NodeId, out ProcessorNode Node))
                    return Node;
            }
 
            foreach (ProcessorNode Node2 in await Database.Find<ProcessorNode>(new FilterFieldEqualTo("NodeId", NodeRef.NodeId)))
            {
                lock (nodes)
                {
                    if (nodes.TryGetValue(NodeRef.NodeId, out ProcessorNode Node))
                        return Node;
                    else
                    {
                        nodes[NodeRef.NodeId] = Node2;
                        return Node2;
                    }
                }
            }
 
            return null;
        }
 
        internal static ProcessorNode RegisterNode(ProcessorNode Node)
        {
            if (Node.SourceId == SourceID && string.IsNullOrEmpty(Node.Partition))
            {
                lock (nodes)
                {
                    if (nodes.TryGetValue(Node.NodeId, out ProcessorNode Node2))
                        return Node2;
                    else
                    {
                        nodes[Node.NodeId] = Node;
                        return Node;
                    }
                }
            }
            else
                return Node;
        }
 
        internal static ProcessorNode RegisterNewNodeId(ProcessorNode Node, string OldId)
        {
            if (Node.SourceId != SourceID || !string.IsNullOrEmpty(Node.Partition))
                return Node;
 
            lock (nodes)
            {
                if (!nodes.TryGetValue(OldId, out ProcessorNode Node2) || Node2 != Node)
                    return Node;
 
                if (nodes.TryGetValue(Node.NodeId, out Node2))
                    return Node2;
 
                nodes.Remove(OldId);
                nodes[Node.NodeId] = Node;
 
                return Node;
            }
        }
 
        internal static void UnregisterNode(ProcessorNode Node)
        {
            if (Node.SourceId == SourceID && string.IsNullOrEmpty(Node.Partition))
            {
                lock (nodes)
                {
                    if (nodes.TryGetValue(Node.NodeId, out ProcessorNode Node2) && Node == Node2)
                        nodes.Remove(Node.NodeId);
                }
            }
        }
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + SourceID + ".View"));
        }
 
        public IEnumerable<INode> RootNodes
        {
            get
            {
                if (root is null)
                    LoadRoot().Wait();
 
                return new INode[] { root };
            }
        }
 
        public static Root Root
        {
            get
            {
                if (root is null)
                    LoadRoot().Wait();
 
                return root;
            }
        }
 
        private static async Task LoadRoot()
        {
            Root Result = null;
 
            foreach (ProcessorNode Node in await Database.Find<ProcessorNode>(new FilterFieldEqualTo("ParentId", Guid.Empty)))
            {
                if (Node is Root Root)
                {
                    if (Result is null)
                        Result = Root;
                    else
                        await Database.Delete(Node);
                }
            }
 
            if (Result is null)
            {
                Result = new Root()
                {
                    NodeId = await (await Translator.GetDefaultLanguageAsync()).GetStringAsync(typeof(Root), 1, "Root")
                };
 
                await Database.Insert(Result);
 
                Language Language = await Translator.GetDefaultLanguageAsync();
                await NewEvent(new NodeAdded()
                {
                    Parameters = await Result.GetDisplayableParameterAraryAsync(Language, RequestOrigin.Empty),
                    NodeType = Result.GetType().FullName,
                    Sniffable = false,
                    DisplayName = await Result.GetTypeNameAsync(Language),
                    HasChildren = Result.HasChildren,
                    ChildrenOrdered = Result.ChildrenOrdered,
                    IsReadable = Result.IsReadable,
                    IsControllable = Result.IsControllable,
                    HasCommands = Result.HasCommands,
                    ParentId = string.Empty,
                    ParentPartition = string.Empty,
                    Updated = Result.Updated,
                    State = Result.State,
                    NodeId = Result.NodeId,
                    Partition = Result.Partition,
                    LogId = NodeAdded.EmptyIfSame(Result.LogId, Result.NodeId),
                    LocalId = NodeAdded.EmptyIfSame(Result.LocalId, Result.NodeId),
                    SourceId = Result.SourceId,
                    Timestamp = DateTime.UtcNow
                });
            }
 
            lock (nodes)
            {
                nodes[Result.NodeId] = Result;
            }
 
            root = Result;
        }
 
        public static async Task<int> DeleteOldEvents(TimeSpan MaxAge)
        {
            if (MaxAge <= TimeSpan.Zero)
                throw new ArgumentException("Age must be positive.", nameof(MaxAge));
 
            DateTime Limit = DateTime.Now.Subtract(MaxAge);
            int NrEvents = await Database.Delete<SourceEvent>(new FilterAnd(
                new FilterFieldEqualTo("SourceId", SourceID), 
                new FilterFieldLesserOrEqualTo("Timestamp", Limit)));
 
            if (NrEvents > 0)
            {
                KeyValuePair<string, object>[] Tags = new KeyValuePair<string, object>[]
                {
                    new KeyValuePair<string, object>("Limit", Limit),
                    new KeyValuePair<string, object>("NrEvents", NrEvents)
                };
 
                if (NrEvents == 1)
                    Log.Informational("Deleting 1 processor event from the database.", SourceID, Tags);
                else
                    Log.Informational("Deleting " + NrEvents.ToString() + " processor events from the database.", SourceID, Tags);
            }
 
            return NrEvents;
        }
 
        public event EventHandlerAsync<SourceEvent> OnEvent = null;
 
        internal static async Task NewEvent(SourceEvent Event)
        {
            await Database.Insert(Event);
            await (instance?.OnEvent?.Raise(instance, Event) ?? Task.CompletedTask);
        }
 
        public static async Task<int> DeleteOrphans()
        {
            int Result = 0;
 
            foreach (ProcessorNode Node in await Database.Find<ProcessorNode>())
            {
                if (Node.ParentId == Guid.Empty)
                    continue;
 
                ProcessorNode ParentNode = await Database.TryLoadObject<ProcessorNode>(Node.ParentId);
                if (ParentNode is null)
                {
                    await Database.Delete(Node);
                    Result++;
 
                    lock (nodes)
                    {
                        nodes.Remove(Node.NodeId);
                    }
                }
            }
 
            return Result;
        }
    }
}