ProgramDataSource.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Waher.Events;
using Waher.IoTGateway;
using Waher.Runtime.Cache;
using Waher.Runtime.Language;
using Waher.Service.IoTBroker.Sources.GatewayConfig;
using Waher.Things;
using Waher.Things.SourceEvents;
 
namespace Waher.Service.IoTBroker.Sources.ProgramData
{
    public class ProgramDataSource : IDataSource, IDisposable
    {
        public const string SourceID = "ProgramData";
 
        private readonly string gatewayConfigFile;
        private readonly string wafFile;
        private FileSystemWatcher watcher;
        private Cache<string, NodeUpdated> delayedUpdates;
 
        public ProgramDataSource()
        {
            this.gatewayConfigFile = Path.Combine(Gateway.AppDataFolder, Gateway.GatewayConfigLocalFileName);
            this.wafFile = Path.Combine(Gateway.AppDataFolder, Gateway.WebApplicationFirewallLocalFileName);
 
            this.delayedUpdates = new Cache<string, NodeUpdated>(int.MaxValue, TimeSpan.FromMinutes(1), TimeSpan.FromSeconds(15));
            this.delayedUpdates.Removed += this.DelayedUpdates_Removed;
 
            this.watcher = new FileSystemWatcher(Gateway.AppDataFolder, "*.*")
            {
                IncludeSubdirectories = true,
                EnableRaisingEvents = true,
                InternalBufferSize = 65536,
                NotifyFilter =
                    NotifyFilters.Attributes |
                    NotifyFilters.CreationTime |
                    NotifyFilters.DirectoryName |
                    NotifyFilters.FileName |
                    NotifyFilters.LastAccess |
                    NotifyFilters.LastWrite |
                    NotifyFilters.Security |
                    NotifyFilters.Size
            };
 
            this.watcher.Changed += this.Watcher_Changed;
            this.watcher.Created += this.Watcher_Created;
            this.watcher.Deleted += this.Watcher_Deleted;
            this.watcher.Renamed += this.Watcher_Renamed;
            this.watcher.Error += this.Watcher_Error;
        }
 
        public void Dispose()
        {
            if (!(this.delayedUpdates is null))
            {
                this.delayedUpdates.Removed -= this.DelayedUpdates_Removed;
                this.delayedUpdates.Dispose();
                this.delayedUpdates = null;
            }
 
            if (!(this.watcher is null))
            {
                this.watcher.Changed -= this.Watcher_Changed;
                this.watcher.Created -= this.Watcher_Created;
                this.watcher.Deleted -= this.Watcher_Deleted;
                this.watcher.Renamed -= this.Watcher_Renamed;
                this.watcher.Error -= this.Watcher_Error;
 
                this.watcher.Dispose();
                this.watcher = null;
            }
        }
 
        string IDataSource.SourceID => SourceID;
 
        public bool HasChildren => false;
 
        public DateTime LastChanged => File.GetLastWriteTimeUtc(Gateway.AppDataFolder);
 
        public IEnumerable<IDataSource> ChildSources => null;
 
        public IEnumerable<INode> RootNodes => GetChildNodes(null, Gateway.AppDataFolder);
 
        public static IEnumerable<INode> GetChildNodes(ProgramDataFolder FolderNode, string FolderPath)
        {
            if (FolderPath != Path.GetFullPath(FolderPath))
                return Array.Empty<INode>();
 
            if (!FolderPath.StartsWith(Gateway.AppDataFolder))
                return Array.Empty<INode>();
 
            SortedDictionary<string, INode> Result1 = new SortedDictionary<string, INode>(StringComparer.InvariantCultureIgnoreCase);
            SortedDictionary<string, INode> Result2 = new SortedDictionary<string, INode>(StringComparer.InvariantCultureIgnoreCase);
 
            FolderNode ??= GetProgramDataNode(FolderPath, false, true) as ProgramDataFolder;
 
            DirectoryInfo DirInfo = new DirectoryInfo(FolderPath);
            if (DirInfo.Exists)
            {
                DirectoryInfo[] Directories = DirInfo.GetDirectories();
                FileInfo[] Files = DirInfo.GetFiles();
 
                foreach (DirectoryInfo Directory in Directories)
                    Result1[Directory.Name] = new ProgramDataFolder(Directory.FullName, FolderNode, Directory.CreationTimeUtc, Directory.LastWriteTimeUtc);
 
                foreach (FileInfo File in Files)
                    Result2[File.Name] = new ProgramDataFile(File.FullName, FolderNode, File.CreationTimeUtc, File.LastAccessTimeUtc, File.Length);
            }
 
            List<INode> Result = new List<INode>();
 
            Result.AddRange(Result1.Values);
            Result.AddRange(Result2.Values);
 
            return Result;
        }
 
        public event EventHandlerAsync<SourceEvent> OnEvent;
 
        public Task<bool> CanViewAsync(RequestOrigin Caller)
        {
            return Task.FromResult(Caller.HasPrivilege("Source." + SourceID + ".View"));
        }
 
        public Task<string> GetNameAsync(Language Language)
        {
            return Language.GetStringAsync(typeof(ProgramDataSource), 1, "Program Data Folder");
        }
 
        public Task<INode> GetNodeAsync(IThingReference NodeRef)
        {
            if (NodeRef.SourceId != SourceID || !string.IsNullOrEmpty(NodeRef.Partition))
                return Task.FromResult<INode>(null);
 
            return Task.FromResult(GetProgramDataNode(NodeRef.NodeId, true, true));
        }
 
        public static INode GetProgramDataNode(string Path, bool FileReference, bool FolderReference)
        {
            if (Path != System.IO.Path.GetFullPath(Path))
                return null;
 
            if (!Path.StartsWith(Gateway.AppDataFolder))
                return null;
 
            INode ParentNode;
            string ParentFolder = Directory.GetParent(Path).FullName;
            if (ParentFolder == Gateway.AppDataFolder)
                ParentNode = null;
            else
                ParentNode = GetProgramDataNode(ParentFolder, false, true);
 
            if (FileReference && File.Exists(Path))
                return new ProgramDataFile(Path, ParentNode as ProgramDataFolder, null, null, null);
 
            if (FolderReference && Directory.Exists(Path))
                return new ProgramDataFolder(Path, ParentNode as ProgramDataFolder, null, null);
 
            return null;
        }
 
        private Task RaiseSourceEvent(SourceEvent Event)
        {
            return this.OnEvent.Raise(this, Event);
        }
 
        private async Task DelayedUpdates_Removed(object Sender, CacheItemEventArgs<string, NodeUpdated> e)
        {
            switch (e.Reason)
            {
                case RemovedReason.Replaced:
                case RemovedReason.Manual:
                    // Ignore
                    break;
 
                case RemovedReason.NotUsed:
                case RemovedReason.Old:
                case RemovedReason.Space:
                default:
                    await this.RaiseSourceEvent(e.Value);
                    break;
            }
        }
 
        private void RaiseSourceEventDelayed(NodeUpdated Event)
        {
            this.delayedUpdates[Event.NodeId] = Event;
        }
 
        private async Task RaiseSourceEventFlushDelayed(NodeEvent Event, bool DiscardDelayed)
        {
            if (DiscardDelayed)
                this.delayedUpdates.Remove(Event.NodeId);
            else if (this.delayedUpdates.TryGetValue(Event.NodeId, out NodeUpdated PrevEvent))
            {
                this.delayedUpdates.Remove(Event.NodeId);
                await this.RaiseSourceEvent(PrevEvent);
            }
 
            await this.RaiseSourceEvent(Event);
        }
 
        private void Watcher_Error(object Sender, ErrorEventArgs e)
        {
            Exception Exception = e.GetException();
            Log.Exception(Exception);
        }
 
        private async void Watcher_Renamed(object Sender, RenamedEventArgs e)
        {
            try
            {
                if (!(this.OnEvent is null))
                {
                    try
                    {
                        INode Node = GetProgramDataNode(e.FullPath, true, true);
 
                        if (!(Node is null))
                        {
                            await this.RaiseSourceEventFlushDelayed(await NodeUpdated.FromNode(Node, await Translator.GetDefaultLanguageAsync(),
                                RequestOrigin.Empty, e.OldFullPath), false);
                        }
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async void Watcher_Deleted(object Sender, FileSystemEventArgs e)
        {
            try
            {
                if (!(this.OnEvent is null))
                {
                    try
                    {
                        INode Node = GetProgramDataNode(e.FullPath, true, true)
                            ?? new ProgramDataFile(e.FullPath, null, null, null, null);
 
                        await this.RaiseSourceEventFlushDelayed(NodeRemoved.FromNode(Node), true);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async void Watcher_Created(object Sender, FileSystemEventArgs e)
        {
            try
            {
                if (!(this.OnEvent is null))
                {
                    try
                    {
                        INode Node = GetProgramDataNode(e.FullPath, true, true);
 
                        if (!(Node is null))
                            await this.RaiseSourceEventFlushDelayed(await NodeAdded.FromNode(Node, await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty, false), true);
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async void Watcher_Changed(object Sender, FileSystemEventArgs e)
        {
            try
            {
                if (!(this.OnEvent is null))
                {
                    try
                    {
                        INode Node = GetProgramDataNode(e.FullPath, true, true);
 
                        if (!(Node is null))
                            this.RaiseSourceEventDelayed(await NodeUpdated.FromNode(Node, await Translator.GetDefaultLanguageAsync(), RequestOrigin.Empty));
                    }
                    catch (Exception ex)
                    {
                        Log.Exception(ex);
                    }
                }
 
                if (string.Compare(e.FullPath, this.gatewayConfigFile, true) == 0)
                    await GatewayConfigSource.FileUpdated();
                else if (string.Compare(e.FullPath, this.wafFile, true) == 0)
                    Gateway.ScheduleEvent(this.ReloadWafDefinition, DateTime.Now.AddSeconds(1), null);
            }
            catch (Exception ex)
            {
                Log.Exception(ex);
            }
        }
 
        private async Task ReloadWafDefinition(object _)
        {
            try
            {
                await Gateway.CheckWAF();
            }
            catch (Exception ex)
            {
                Log.Exception(ex, this.wafFile);
            }
        }
 
    }
}