More file system watcher error handling.

src/file_system_watcher.rs

 use std::sync::Arc;
 use std::time::Duration;
 
-use fswatcher::{FileEventDelay, FileSystemEvent};
+use fswatcher::{FileEventDelay, FileSystemEvent, StopReason};
 use futures::future::{self, Either};
 use tokio::stream::StreamExt;
 use tokio::sync::{mpsc, oneshot, Mutex};
         };
         let mut file_events = FileEventDelay::new(fsw, Duration::from_secs(3));
 
-        loop {
+        let mut error_needs_pause = None;
+        while error_needs_pause.is_none() {
             // We only want to wait for file system events until a state change pauses the file
             // system watcher.
             match future::select(Box::pin(file_events.next()), Box::pin(state_receive.recv())).await
                 Either::Left((event, _state_future)) => {
                     // We cannot get any end-of-stream None here - we would first get a "Stopped"
                     // file event.
-                    Self::handle_file_event(file_tree, event.unwrap()).await;
+                    if let Err(error) =
+                        Self::handle_file_event(file_tree, errors, event.unwrap()).await
+                    {
+                        error_needs_pause = Some(error);
+                    }
                 }
                 Either::Right((next_state, _file_event_future)) => {
                     match next_state.unwrap() {
                 }
             };
         }
+        return Self::wait_for_pause(error_needs_pause.unwrap(), state_receive, errors).await;
     }
 
     async fn wait_for_pause(
                 (StateChange::Terminate, _) => return StateChange::Terminate,
             }
         }
-        // TODO
     }
 
-    async fn handle_file_event(_file_tree: &mut Arc<Mutex<FileTree>>, event: FileSystemEvent) {
+    async fn handle_file_event(
+        _file_tree: &mut Arc<Mutex<FileTree>>,
+        errors: &mut mpsc::Sender<SynchronizationError>,
+        event: FileSystemEvent,
+    ) -> Result<(), Error> {
         match event {
-            FileSystemEvent::Stopped(_reason) => {
-                // TODO
-            }
+            FileSystemEvent::Stopped(reason) => match reason {
+                StopReason::DirectoryRemoved => {
+                    return Err(Error::DirectoryRemoved);
+                }
+            },
             FileSystemEvent::DirectoryWatched(_path) => {
                 // TODO
             }
             FileSystemEvent::FileMoved(_from, _to) => {
                 // TODO
             }
-            FileSystemEvent::Error(_e) => {
-                // TODO
+            FileSystemEvent::Error(e) => {
+                errors
+                    .send(SynchronizationError {
+                        needs_pause: false,
+                        error: e.into(),
+                    })
+                    .await
+                    .ok();
             }
         }
 
         // TODO: Check whether this is really necessary and how large the impact on
         // performance is.
         task::yield_now().await;
+        Ok(())
     }
 }
 

src/lib.rs

 #[derive(Debug)]
 pub enum Error {
     Io(std::io::Error),
+    DirectoryRemoved,
 }
 
 impl From<io::Error> for Error {