Add code to iterate through file system events.

src/file_system_watcher.rs

@@ -1,11 +1,11 @@
-use std::collections::{VecDeque, HashMap};
 use std::sync::Arc;
-use std::path::Path;
 use std::time::Duration;
 
+use fswatcher::{FileEventDelay, FileSystemEvent};
+use futures::future::{self, Either};
+use tokio::stream::StreamExt;
 use tokio::sync::{mpsc, oneshot, Mutex};
 use tokio::task;
-use fswatcher::FileEventDelay;
 
 use super::{Error, FileTree};
 
@@ -73,45 +73,78 @@ impl FileSystemWatcher {
 
     async fn task_unpaused(
         file_tree: &mut Arc<Mutex<FileTree>>,
-        _state_receive: &mut mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
+        state_receive: &mut mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
     ) -> StateChange {
         let root_path = file_tree.lock().await.root_path().to_owned();
         // TODO: Proper error handling.
-        let file_events = FileEventDelay::new(fswatcher::FileSystemWatcher::new(&root_path).unwrap(), Duration::from_secs(3));
+        let mut file_events = FileEventDelay::new(
+            fswatcher::FileSystemWatcher::new(&root_path).unwrap(),
+            Duration::from_secs(3),
+        );
 
         loop {
-            /*if new_directories.is_empty() {
-                // If all the inotify watches are up-to-date, simply wait for any events.
-                let event = file_events.next(&paths_by_watch).await;
-                // TODO
-            } else {
-                // Install an inotify watch for the directory and check the directory contents
-                // against the database.
-                let new_directory = new_directories.pop_front().unwrap();
-                // TODO: Do not follow links!
-                // TODO: Is ONLYDIR correct?
-                // TODO: We want to delay events for 2-3 seconds, so that we limit the rate of
-                // modification events and so that we are maybe able to detect moved
-                // files/directories across different directories!
-                if Path::new(&new_directory).is_dir() {
-                    let watch = inotify.add_watch(new_directory, WatchMask::ATTRIB | WatchMask::CLOSE_WRITE | WatchMask::CREATE | WatchMask::DELETE | WatchMask::DELETE_SELF | WatchMask::MODIFY | WatchMask::MOVE | WatchMask::EXCL_UNLINK | WatchMask::ONLYDIR);
-                    // TODO
+            match future::select(Box::pin(file_events.next()), Box::pin(state_receive.recv())).await
+            {
+                Either::Left((event, _state_future)) => {
+                    // TODO: Error handling, handle None event.
+                    Self::handle_file_event(file_tree, event.unwrap()).await;
                 }
+                Either::Right((next_state, _file_event_future)) => {
+                    match next_state.unwrap() {
+                        (StateChange::Unpause, send) => send.send(()).unwrap(),
+                        (StateChange::Pause, send) => {
+                            send.send(()).unwrap();
+                            return StateChange::Pause;
+                        }
+                        (StateChange::Terminate, _) => return StateChange::Pause,
+                    };
+                }
+            };
+        }
+    }
 
-                // Proceed recursively at the next loop iteration.
+    async fn handle_file_event(_file_tree: &mut Arc<Mutex<FileTree>>, event: FileSystemEvent) {
+        match event {
+            FileSystemEvent::Stopped(_reason) => {
                 // TODO
-
-                // Poll for events (without blocking, so that we immediately process the next
-                // directory if nothing happened).
+            }
+            FileSystemEvent::DirectoryWatched(_path) => {
                 // TODO
-
-                // Yield to other parts of the program to minimize the impact of scanning large
-                // directory trees.
-                // TODO: Check whether this is really necessary and how large the impact on
-                // performance is.
-                task::yield_now().await;
-            }*/
+            }
+            FileSystemEvent::DirectoryCreated(_path) => {
+                // TODO
+            }
+            FileSystemEvent::DirectoryModified(_path) => {
+                // TODO
+            }
+            FileSystemEvent::DirectoryRemoved(_path) => {
+                // TODO
+            }
+            FileSystemEvent::DirectoryMoved(_from, _to) => {
+                // TODO
+            }
+            FileSystemEvent::FileCreated(_path) => {
+                // TODO
+            }
+            FileSystemEvent::FileModified(_path) => {
+                // TODO
+            }
+            FileSystemEvent::FileRemoved(_path) => {
+                // TODO
+            }
+            FileSystemEvent::FileMoved(_from, _to) => {
+                // TODO
+            }
+            FileSystemEvent::Error(_e) => {
+                // TODO
+            }
         }
+
+        // Yield to other parts of the program to minimize the impact of scanning large
+        // directory trees.
+        // TODO: Check whether this is really necessary and how large the impact on
+        // performance is.
+        task::yield_now().await;
     }
 }