FileSystemWatcher.Linux/OSX: raise Error event when FileSystemWatcher's watched directory is deleted or moved.

Author: tmds

src/libraries/Common/src/Interop/Linux/System.Native/Interop.INotify.cs

@@ -51,6 +51,7 @@ internal enum NotifyEvents
             IN_MOVED_TO    = 0x00000080,
             IN_CREATE      = 0x00000100,
             IN_DELETE      = 0x00000200,
+            IN_MOVE_SELF   = 0x00000800,
             IN_Q_OVERFLOW  = 0x00004000,
             IN_IGNORED     = 0x00008000,
             IN_ONLYDIR     = 0x01000000,

src/libraries/Microsoft.Extensions.FileProviders.Physical/src/PhysicalFilesWatcher.cs

@@ -525,56 +525,42 @@ private void TryEnableFileSystemWatcher()
                     return;
                 }
 
-                if (!_filePathTokenLookup.IsEmpty || !_wildcardTokenLookup.IsEmpty)
+                if (!_fileWatcher.EnableRaisingEvents && (!_filePathTokenLookup.IsEmpty || !_wildcardTokenLookup.IsEmpty))
                 {
-                    bool rootExists = Directory.Exists(_root);
-
-                    // On some platforms (e.g., Linux), FileSystemWatcher currently does not
-                    // invoke OnError when the watched directory is deleted, so we don't disable
-                    // the FSW and start root watcher at that point.
-                    // Detect and handle this opportunistically now.
-                    if (_fileWatcher.EnableRaisingEvents && !rootExists)
+                    if (!Directory.Exists(_root))
                     {
-                        _fileWatcher.EnableRaisingEvents = false;
+                        needsRootWatcher = true;
+                        _rootWasUnavailable = true;
                     }
-
-                    if (!_fileWatcher.EnableRaisingEvents)
+                    else
                     {
-                        if (!rootExists)
+                        try
                         {
-                            needsRootWatcher = true;
-                            _rootWasUnavailable = true;
+                            if (string.IsNullOrEmpty(_fileWatcher.Path))
+                            {
+                                _fileWatcher.Path = _root;
+                            }
+
+                            _fileWatcher.EnableRaisingEvents = true;
+
+                            // Only scan for existing entries if the FSW was enabled after _root
+                            // was initially missing (i.e. we went through the PCW path). In the
+                            // normal case where _root always existed, there is no gap to cover.
+                            justEnabledAfterRootCreated = _rootWasUnavailable;
+                            _rootWasUnavailable = false;
                         }
-                        else
+                        catch (Exception ex) when (ex is ArgumentException or IOException)
                         {
-                            try
+                            // _root may have been deleted between the Directory.Exists check
+                            // and the property sets above. Fall back to watching for root creation.
+                            if (!Directory.Exists(_root))
                             {
-                                if (string.IsNullOrEmpty(_fileWatcher.Path))
-                                {
-                                    _fileWatcher.Path = _root;
-                                }
-
-                                _fileWatcher.EnableRaisingEvents = true;
-
-                                // Only scan for existing entries if the FSW was enabled after _root
-                                // was initially missing (i.e. we went through the PCW path). In the
-                                // normal case where _root always existed, there is no gap to cover.
-                                justEnabledAfterRootCreated = _rootWasUnavailable;
-                                _rootWasUnavailable = false;
+                                needsRootWatcher = true;
+                                _rootWasUnavailable = true;
                             }
-                            catch (Exception ex) when (ex is ArgumentException or IOException)
+                            else
                             {
-                                // _root may have been deleted between the Directory.Exists check
-                                // and the property sets above. Fall back to watching for root creation.
-                                if (!Directory.Exists(_root))
-                                {
-                                    needsRootWatcher = true;
-                                    _rootWasUnavailable = true;
-                                }
-                                else
-                                {
-                                    throw;
-                                }
+                                throw;
                             }
                         }
                     }

src/libraries/System.IO.FileSystem.Watcher/src/Resources/Strings.resx

@@ -125,6 +125,9 @@
   <data name="FSW_BufferOverflow" xml:space="preserve">
     <value>Too many changes at once in directory:{0}.</value>
   </data>
+  <data name="FSW_WatchedDirectoryDeletedOrMoved" xml:space="preserve">
+    <value>The directory being watched '{0}' was deleted or moved.</value>
+  </data>
   <data name="InvalidDirName" xml:space="preserve">
     <value>The directory name {0} is invalid.</value>
   </data>

src/libraries/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Linux.cs

@@ -242,7 +242,8 @@ private void StopINotify()
                         Interop.Sys.NotifyEvents mask = watchFilters |
                             Interop.Sys.NotifyEvents.IN_ONLYDIR |     // we only allow watches on directories
                             Interop.Sys.NotifyEvents.IN_EXCL_UNLINK | // we want to stop monitoring unlinked files
-                            (parent == null ? 0 : Interop.Sys.NotifyEvents.IN_DONT_FOLLOW); // Follow links only for the root path, not the subdirs.
+                            (parent == null ? Interop.Sys.NotifyEvents.IN_MOVE_SELF // Detect when the root directory is moved.
+                                            : Interop.Sys.NotifyEvents.IN_DONT_FOLLOW); // Follow links only for the root path, not the subdirs.
 
                         // To support multiple FileSystemWatchers on the same inotify instance, we need to use IN_MASK_ADD
                         // so we don't remove events another watcher is interested in.
@@ -657,9 +658,17 @@ private unsafe bool ProcessEvent(NotifyEvent nextEvent, ref int movedFromWatchCo
                         }
                     }
                     // IN_IGNORED: Watch was removed explicitly or automatically because the directory was deleted.
-                    if ((mask & Interop.Sys.NotifyEvents.IN_IGNORED) != 0)
+                    // IN_MOVE_SELF: A root directory was moved.
+                    if (((mask & Interop.Sys.NotifyEvents.IN_IGNORED) != 0)
+                        || (((mask & Interop.Sys.NotifyEvents.IN_MOVE_SELF) != 0) && dir.IsRootDir))
                     {
-                        RemoveWatchedDirectory(dir, ignoredFd: nextEvent.wd);
+                        int ignoredFd = (mask & Interop.Sys.NotifyEvents.IN_IGNORED) != 0 ? nextEvent.wd : -1;
+                        RemoveWatchedDirectory(dir, ignoredFd);
+
+                        if (dir.IsRootDir && !watcher.IsWatcherStopped)
+                        {
+                            watcher.QueueError(CreateWatchedDirectoryDeletedOrMovedException(watcher.BasePath));
+                        }
                         continue;
                     }
 
@@ -1248,10 +1257,7 @@ private static Interop.Sys.NotifyEvents TranslateFilters(NotifyFilters filters)
 
                     // For the Created and Deleted events, we need to always
                     // register for the created/deleted inotify events, regardless
-                    // of the supplied filters values. We explicitly don't include IN_DELETE_SELF.
-                    // The Windows implementation doesn't include notifications for the root directory,
-                    // and having this for subdirectories results in duplicate notifications, one from
-                    // the parent and one from self.
+                    // of the supplied filters values.
                     result |=
                         Interop.Sys.NotifyEvents.IN_CREATE |
                         Interop.Sys.NotifyEvents.IN_DELETE;

src/libraries/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.OSX.cs

@@ -438,6 +438,14 @@ private unsafe void ProcessEvents(int numEvents,
                     ReadOnlySpan<char> path = parsedEvent.Path;
                     Debug.Assert(path[^1] != '/', "Trailing slashes on events is not supported");
 
+                    // Root was deleted/renamed.
+                    if (eventFlags[i].HasFlag(FSEventStreamEventFlags.kFSEventStreamEventFlagRootChanged))
+                    {
+                        watcher.OnError(new ErrorEventArgs(CreateWatchedDirectoryDeletedOrMovedException(_fullDirectory)));
+                        CleanupEventStream();
+                        return;
+                    }
+
                     // Match Windows and don't notify us about changes to the Root folder
                     if (_fullDirectory.Length >= path.Length && path.Equals(_fullDirectory.AsSpan(0, path.Length), StringComparison.OrdinalIgnoreCase))
                     {
@@ -609,7 +617,6 @@ private static bool ShouldRescanOccur(FSEventStreamEventFlags flags)
                 return (flags.HasFlag(FSEventStreamEventFlags.kFSEventStreamEventFlagMustScanSubDirs) ||
                         flags.HasFlag(FSEventStreamEventFlags.kFSEventStreamEventFlagUserDropped) ||
                         flags.HasFlag(FSEventStreamEventFlags.kFSEventStreamEventFlagKernelDropped) ||
-                        flags.HasFlag(FSEventStreamEventFlags.kFSEventStreamEventFlagRootChanged) ||
                         flags.HasFlag(FSEventStreamEventFlags.kFSEventStreamEventFlagMount) ||
                         flags.HasFlag(FSEventStreamEventFlags.kFSEventStreamEventFlagUnmount));
             }

src/libraries/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.cs

@@ -404,6 +404,9 @@ private void NotifyInternalBufferOverflowEvent()
         private static InternalBufferOverflowException CreateBufferOverflowException(string directoryPath)
             => new InternalBufferOverflowException(SR.Format(SR.FSW_BufferOverflow, directoryPath));
 
+        private static DirectoryNotFoundException CreateWatchedDirectoryDeletedOrMovedException(string directoryPath)
+            => new DirectoryNotFoundException(SR.Format(SR.FSW_WatchedDirectoryDeletedOrMoved, directoryPath));
+
         /// <summary>
         /// Raises the event to each handler in the list.
         /// </summary>

src/libraries/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.Directory.Delete.cs

@@ -99,5 +99,17 @@ public void FileSystemWatcher_Directory_Delete_SynchronizingObject()
                 Assert.True(invoker.BeginInvoke_Called);
             }
         }
+
+        [Fact]
+        public void FileSystemWatcher_WatchedDirectory_Delete()
+        {
+            string dir = CreateTestDirectory(TestDirectory, "watched");
+            using var watcher = new FileSystemWatcher(dir);
+
+            Action action = () => Directory.Delete(dir, recursive: true);
+            Action cleanup = () => Directory.CreateDirectory(dir);
+
+            ExpectError(watcher, action, cleanup);
+        }
     }
 }

src/libraries/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.Directory.Move.cs

@@ -116,6 +116,20 @@ public void Directory_Move_SynchronizingObject()
             }
         }
 
+        [Fact]
+        [PlatformSpecific(TestPlatforms.AnyUnix)] // Windows directory handles follow the directory on move; no error is raised.
+        public void FileSystemWatcher_WatchedDirectory_Move()
+        {
+            string dir = CreateTestDirectory(TestDirectory, "watched");
+            string targetDir = Path.Combine(TestDirectory, "moved");
+            using var watcher = new FileSystemWatcher(dir);
+
+            Action action = () => Directory.Move(dir, targetDir);
+            Action cleanup = () => Directory.Move(targetDir, dir);
+
+            ExpectError(watcher, action, cleanup);
+        }
+
         #region Test Helpers
 
         private void DirectoryMove_SameDirectory(WatcherChangeTypes eventType)