Preserve IO errors in PollWatcher

notify-types/src/event.rs

@@ -195,7 +195,10 @@ pub enum RemoveKind {
 #[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(rename_all = "kebab-case"))]
-#[cfg_attr(all(feature = "serde", not(feature = "serialization-compat-6")), serde(tag = "type"))]
+#[cfg_attr(
+    all(feature = "serde", not(feature = "serialization-compat-6")),
+    serde(tag = "type")
+)]
 pub enum EventKind {
     /// The catch-all event kind, for unsupported/unknown events.
     ///
@@ -300,7 +303,10 @@ pub struct Event {
     /// The `EventKind::Any` variant should be used as the "else" case when mapping native kernel
     /// bitmasks or bitmaps, such that if the mask is ever extended with new event types the
     /// backend will not gain bugs due to not matching new unknown event types.
-    #[cfg_attr(all(feature = "serde", not(feature = "serialization-compat-6")), serde(flatten))]
+    #[cfg_attr(
+        all(feature = "serde", not(feature = "serialization-compat-6")),
+        serde(flatten)
+    )]
     pub kind: EventKind,
 
     /// Paths the event is about, if known.
@@ -478,7 +484,10 @@ impl EventAttributes {
 /// particular ways.
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
-#[cfg_attr(all(feature = "serde", not(feature = "serialization-compat-6")), serde(rename_all = "camelCase"))]
+#[cfg_attr(
+    all(feature = "serde", not(feature = "serialization-compat-6")),
+    serde(rename_all = "camelCase")
+)]
 pub enum Flag {
     /// Rescan notices are emitted by some platforms (and may also be emitted by Notify itself).
     /// They indicate either a lapse in the events or a change in the filesystem such that events

notify/src/poll.rs

@@ -182,7 +182,7 @@ mod data {
             // FIXME: Can we always allow to watch a path, even file not
             // found at this path?
             if let Err(e) = fs::metadata(&root) {
-                data_builder.emitter.emit_io_err(e, &root);
+                data_builder.emitter.emit_io_err(e, Some(&root));
                 return None;
             }
 
@@ -259,25 +259,19 @@ mod data {
                 .follow_links(true)
                 .max_depth(Self::dir_scan_depth(is_recursive))
                 .into_iter()
-                //
-                // QUESTION: should we ignore IO Error?
-                //
-                // current implementation ignore some IO error, e.g.,
-                //
-                // - `.filter_map(|entry| entry.ok())`
-                // - all read error when hashing
-                //
-                // but the code also interest with `fs::metadata()` error and
-                // propagate to event handler. It may not consistent.
-                //
-                // FIXME: Should we emit all IO error events? Or ignore them all?
                 .filter_map(|entry_res| match entry_res {
                     Ok(entry) => Some(entry),
                     Err(err) => {
                         log::warn!("walkdir error scanning {err:?}");
-                        let crate_err =
-                            crate::Error::new(crate::ErrorKind::Generic(err.to_string()));
-                        data_builder.emitter.emit(Err(crate_err));
+                        if let Some(io_error) = err.io_error() {
+                            // clone an io::Error, so we have to create a new one.
+                            let new_io_error = io::Error::new(io_error.kind(), err.to_string());
+                            data_builder.emitter.emit_io_err(new_io_error, err.path());
+                        } else {
+                            let crate_err =
+                                crate::Error::new(crate::ErrorKind::Generic(err.to_string()));
+                            data_builder.emitter.emit(Err(crate_err));
+                        }
                         None
                     }
                 })
@@ -298,7 +292,7 @@ mod data {
                     Err(e) => {
                         // emit event.
                         let path = entry.into_path();
-                        data_builder.emitter.emit_io_err(e, path);
+                        data_builder.emitter.emit_io_err(e, Some(path));
 
                         None
                     }
@@ -455,12 +449,17 @@ mod data {
         }
 
         /// Emit io error event.
-        fn emit_io_err<E, P>(&self, err: E, path: P)
+        fn emit_io_err<E, P>(&self, err: E, path: Option<P>)
         where
             E: Into<io::Error>,
             P: Into<PathBuf>,
         {
-            self.emit(Err(crate::Error::io(err.into()).add_path(path.into())))
+            let e = crate::Error::io(err.into());
+            if let Some(path) = path {
+                self.emit(Err(e.add_path(path.into())));
+            } else {
+                self.emit(Err(e));
+            }
         }
     }
 }