Implement custom FileSystemWatchers

Author: austinv900

src/OxideMod.cs

@@ -18,6 +18,9 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading;
+using Oxide.IO;
+using Oxide.IO.Unix;
+using Oxide.IO.Windows;
 using Timer = Oxide.Core.Libraries.Timer;
 
 namespace Oxide.Core
@@ -67,6 +70,10 @@ public sealed class OxideMod
         public string LangDirectory { get; private set; }
         public string LogDirectory { get; private set; }
 
+        public IFileSystem FileSystem { get; private set; }
+
+        public IFileSystemWatcher FileWatcher { get; private set; }
+
         // Gets the number of seconds since the server started
         public float Now => getTimeSinceStartup();
 
@@ -143,7 +150,9 @@ public void Load()
                 CommandLine.GetArgument("oxide.directory", out string var, out string format);
                 if (string.IsNullOrEmpty(var) || CommandLine.HasVariable(var))
                 {
-                    InstanceDirectory = Path.Combine(RootDirectory, Utility.CleanPath(string.Format(format, CommandLine.GetVariable(var))));
+                    InstanceDirectory = Path.Combine(RootDirectory,
+                                                     Utility.CleanPath(string.Format(format,
+                                                                        CommandLine.GetVariable(var))));
                 }
             }
 
@@ -243,6 +252,21 @@ public void Load()
             extensionManager.RegisterLibrary("Timer", libtimer = new Timer());
             extensionManager.RegisterLibrary("WebRequests", new WebRequests());
 
+            if (Environment.OSVersion.Platform == PlatformID.Unix || Environment.OSVersion.Platform == PlatformID.MacOSX)
+            {
+                FileSystem = new UnixFileSystem();
+                FileWatcher = new UnixFileSystemWatcher(FileSystem, InstanceDirectory, true, NotifyMask.Default);
+            }
+            else
+            {
+                FileSystem = new WindowsFileSystem();
+                FileWatcher = new WindowsFileSystemWatcher(FileSystem, InstanceDirectory, true, NotifyMask.Default);
+            }
+
+            FileWatcher.Ignore("*.log")
+                       .Ignore("*.txt")
+                       .BeginInit();
+
             LogInfo("Loading extensions...");
             extensionManager.LoadAllExtensions(ExtensionDirectory);
 
@@ -273,6 +297,8 @@ public void Load()
                 watcher.OnPluginAdded += watcher_OnPluginAdded;
                 watcher.OnPluginRemoved += watcher_OnPluginRemoved;
             }
+
+            FileWatcher.EndInit();
         }
 
         /// <summary>
@@ -756,6 +782,7 @@ public void OnShutdown()
                 RemoteConsole?.Shutdown();
                 ServerConsole?.OnDisable();
                 RootLogger.Shutdown();
+                FileWatcher.Dispose();
             }
         }
 

src/Plugins/Watchers/FSWatcher.cs

@@ -1,122 +1,73 @@
 extern alias References;
 
 using Oxide.Core.Libraries;
-using References::Mono.Posix;
 using System;
 using System.Collections.Generic;
 using System.IO;
-#if !NETSTANDARD
-using System.Security.Permissions;
-#endif
 using System.Text.RegularExpressions;
+using Oxide.IO;
 
 namespace Oxide.Core.Plugins.Watchers
 {
     /// <summary>
     /// Represents a file system watcher
     /// </summary>
-    public sealed class FSWatcher : PluginChangeWatcher
+    public sealed class FSWatcher : PluginChangeWatcher, IObserver<FileSystemEvent>
     {
         private class QueuedChange
         {
             internal WatcherChangeTypes type;
             internal Timer.TimerInstance timer;
         }
 
-        // The filesystem watcher
-        private FileSystemWatcher watcher;
-
         // The plugin list
         private ICollection<string> watchedPlugins;
+        private Timer timers;
+        private readonly string _directory;
+        private readonly Regex filter;
+        private readonly IFileSystemWatcher watcher;
+        private readonly IDisposable subscription;
 
-        // Changes are buffered briefly to avoid duplicate events
-        private Dictionary<string, QueuedChange> changeQueue;
+        public FSWatcher(IFileSystemWatcher watcher, string watchedDirectory, string fileFilter = "*")
+        {
+            if (!watchedDirectory.StartsWith(watcher.Directory, StringComparison.InvariantCulture))
+            {
+                throw new ArgumentException($"Path must be begin with {watcher.Directory}", nameof(watchedDirectory));
+            }
 
-        private Timer timers;
+            if (string.IsNullOrEmpty(fileFilter))
+            {
+                fileFilter = "*";
+            }
 
-        private Dictionary<string, FileSystemWatcher> m_symlinkWatchers = new Dictionary<string, FileSystemWatcher>();
+            _directory = watchedDirectory;
+            fileFilter = Regex.Escape(fileFilter)
+                              .Replace("\\*", ".*")
+                              .Replace("\\?", ".");
+            fileFilter = "^" + fileFilter + "$";
+            filter = new Regex(fileFilter, RegexOptions.Compiled | RegexOptions.IgnoreCase);
+            this.watcher = watcher;
 
-        /// <summary>
-        /// Initializes a new instance of the FSWatcher class
-        /// </summary>
-        /// <param name="directory"></param>
-        /// <param name="filter"></param>
-        public FSWatcher(string directory, string filter)
-        {
             watchedPlugins = new HashSet<string>();
-            changeQueue = new Dictionary<string, QueuedChange>();
             timers = Interface.Oxide.GetLibrary<Timer>();
 
             if (Interface.Oxide.Config.Options.PluginWatchers)
             {
-                LoadWatcher(directory, filter);
-
-                // Watch symlinked files
-                if (Environment.OSVersion.Platform == PlatformID.Unix)
-                {
-                    foreach (FileInfo fileInfo in new DirectoryInfo(directory).GetFiles(filter))
-                    {
-                        if (IsFileSymlink(fileInfo.FullName))
-                        {
-                            LoadWatcherSymlink(fileInfo.FullName);
-                        }
-                    }
-                }
+                subscription = this.watcher.Subscribe(this);
             }
             else
             {
                 Interface.Oxide.LogWarning("Automatic plugin reloading and unloading has been disabled");
             }
         }
 
-        private bool IsFileSymlink(string path)
-        {
-            return (File.GetAttributes(path) & FileAttributes.ReparsePoint) > 0;
-        }
-
-
-#if !NETSTANDARD
-        [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
-#endif
-        private void LoadWatcherSymlink(string path)
-        {
-            string realPath = Syscall.readlink(path);
-            string realDirName = Path.GetDirectoryName(realPath);
-            string realFileName = Path.GetFileName(realPath);
-
-            void symlinkTarget_Changed(object sender, FileSystemEventArgs e) => watcher_Changed(sender, e);
-
-            FileSystemWatcher watcher = new FileSystemWatcher(realDirName, realFileName);
-            m_symlinkWatchers[path] = watcher;
-            watcher.Changed += symlinkTarget_Changed;
-            watcher.Created += symlinkTarget_Changed;
-            watcher.Deleted += symlinkTarget_Changed;
-            watcher.Error += watcher_Error;
-            watcher.NotifyFilter = NotifyFilters.LastWrite;
-            watcher.IncludeSubdirectories = false;
-            watcher.EnableRaisingEvents = true;
-        }
-
         /// <summary>
-        /// Loads the filesystem watcher
+        /// Initializes a new instance of the FSWatcher class
         /// </summary>
         /// <param name="directory"></param>
         /// <param name="filter"></param>
-#if !NETSTANDARD
-        [PermissionSet(SecurityAction.Demand, Name = "FullTrust")]
-#endif
-        private void LoadWatcher(string directory, string filter)
+        public FSWatcher(string directory, string filter = "*") : this(Interface.Oxide.FileWatcher, directory, filter)
         {
-            // Create the watcher
-            watcher = new FileSystemWatcher(directory, filter);
-            watcher.Changed += watcher_Changed;
-            watcher.Created += watcher_Changed;
-            watcher.Deleted += watcher_Changed;
-            watcher.Error += watcher_Error;
-            watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName;
-            watcher.IncludeSubdirectories = true;
-            watcher.EnableRaisingEvents = true;
-            GC.KeepAlive(watcher);
         }
 
         /// <summary>
@@ -136,126 +87,77 @@ private void LoadWatcher(string directory, string filter)
         /// </summary>
         /// <param name="sender"></param>
         /// <param name="e"></param>
-        private void watcher_Changed(object sender, FileSystemEventArgs e)
+        private void watcher_Changed(object sender, FileSystemEvent e)
         {
-            FileSystemWatcher watcher = (FileSystemWatcher)sender;
-            int length = e.FullPath.Length - watcher.Path.Length - Path.GetExtension(e.Name).Length - 1;
-            string subPath = e.FullPath.Substring(watcher.Path.Length + 1, length);
-
-            if (!changeQueue.TryGetValue(subPath, out QueuedChange change))
-            {
-                change = new QueuedChange();
-                changeQueue[subPath] = change;
-            }
-            change.timer?.Destroy();
-            change.timer = null;
-
-            switch (e.ChangeType)
-            {
-                case WatcherChangeTypes.Changed:
-                    if (change.type != WatcherChangeTypes.Created)
-                    {
-                        change.type = WatcherChangeTypes.Changed;
-                    }
-                    break;
-
-                case WatcherChangeTypes.Created:
-                    if (change.type == WatcherChangeTypes.Deleted)
-                    {
-                        change.type = WatcherChangeTypes.Changed;
-                    }
-                    else
-                    {
-                        change.type = WatcherChangeTypes.Created;
-                    }
-                    break;
-
-                case WatcherChangeTypes.Deleted:
-                    if (change.type == WatcherChangeTypes.Created)
-                    {
-                        changeQueue.Remove(subPath);
-                        return;
-                    }
-
-                    change.type = WatcherChangeTypes.Deleted;
-                    break;
-            }
+            string fullPath = Path.Combine(e.Directory, e.Name);
+            int length = fullPath.Length - _directory.Length - Path.GetExtension(e.Name).Length - 1;
+            string subPath = fullPath.Substring(_directory.Length + 1, length);
 
             Interface.Oxide.NextTick(() =>
             {
-                if (Environment.OSVersion.Platform == PlatformID.Unix)
+                if (Regex.Match(subPath, @"include\\", RegexOptions.IgnoreCase).Success)
                 {
-                    switch (e.ChangeType)
+                    if (e.Event == NotifyMask.OnCreated || e.Event == NotifyMask.OnModified)
                     {
-                        case WatcherChangeTypes.Created:
-                            if (IsFileSymlink(e.FullPath))
-                            {
-                                LoadWatcherSymlink(e.FullPath);
-                            }
-                            break;
-
-                        case WatcherChangeTypes.Deleted:
-                            if (m_symlinkWatchers.ContainsKey(e.FullPath))
-                            {
-                                m_symlinkWatchers.TryGetValue(e.FullPath, out FileSystemWatcher symlinkWatcher);
-                                symlinkWatcher?.Dispose();
-                                m_symlinkWatchers.Remove(e.FullPath);
-                            }
-                            break;
+                        FirePluginSourceChanged(subPath);
                     }
+
+                    return;
                 }
 
-                change.timer?.Destroy();
-                change.timer = timers.Once(.2f, () =>
+                switch (e.Event)
                 {
-                    change.timer = null;
-                    changeQueue.Remove(subPath);
-
-                    if (Regex.Match(subPath, @"include\\", RegexOptions.IgnoreCase).Success)
-                    {
-                        if (change.type == WatcherChangeTypes.Created || change.type == WatcherChangeTypes.Changed)
+                    case NotifyMask.OnModified:
+                        if (watchedPlugins.Contains(subPath))
                         {
                             FirePluginSourceChanged(subPath);
                         }
-
-                        return;
-                    }
-
-                    switch (change.type)
-                    {
-                        case WatcherChangeTypes.Changed:
-                            if (watchedPlugins.Contains(subPath))
-                            {
-                                FirePluginSourceChanged(subPath);
-                            }
-                            else
-                            {
-                                FirePluginAdded(subPath);
-                            }
-                            break;
-
-                        case WatcherChangeTypes.Created:
+                        else
+                        {
                             FirePluginAdded(subPath);
-                            break;
+                        }
+                        break;
 
-                        case WatcherChangeTypes.Deleted:
-                            if (watchedPlugins.Contains(subPath))
-                            {
-                                FirePluginRemoved(subPath);
-                            }
-                            break;
-                    }
-                });
+                    case NotifyMask.OnCreated:
+                        FirePluginAdded(subPath);
+                        break;
+
+                    case NotifyMask.OnDeleted:
+                        if (watchedPlugins.Contains(subPath))
+                        {
+                            FirePluginRemoved(subPath);
+                        }
+                        break;
+                }
             });
         }
 
-        private void watcher_Error(object sender, ErrorEventArgs e)
+        public void OnNext(FileSystemEvent value)
         {
-            Interface.Oxide.NextTick(() =>
+            if (!value.Directory.StartsWith(_directory, StringComparison.InvariantCulture) || !filter.IsMatch(value.Name))
             {
-                Interface.Oxide.LogError("FSWatcher error: {0}", e.GetException());
-                RemoteLogger.Exception("FSWatcher error", e.GetException());
-            });
+                return;
+            }
+
+            if ((value.Event & NotifyMask.DirectoryOnly) == NotifyMask.DirectoryOnly)
+            {
+                return;
+            }
+
+#if DEBUG
+            Interface.Oxide.LogDebug($"Processing {value.Event}: {Path.Combine(value.Directory, value.Name)}");
+#endif
+            watcher_Changed(watcher, value);
+        }
+
+        public void OnError(Exception error)
+        {
+            Interface.Oxide.LogError("FSWatcher error: {0}", error);
+            RemoteLogger.Exception("FSWatcher error", error);
+        }
+
+        public void OnCompleted()
+        {
         }
     }
 }