Add code to pause/unpause the file system watcher.

src/file_system_watcher.rs

@@ -0,0 +1,83 @@
+use std::sync::Arc;
+
+use tokio::sync::{mpsc, oneshot, Mutex};
+
+use super::{Error, FileTree};
+
+pub struct FileSystemWatcher {
+    state_send: mpsc::Sender<(StateChange, oneshot::Sender<()>)>,
+}
+
+impl FileSystemWatcher {
+    pub fn new(file_tree: Arc<Mutex<FileTree>>) -> Result<FileSystemWatcher, Error> {
+        // Spawn the task that watches the file system as soon as unpause() is called.
+        let (state_send, pause_receive) = mpsc::channel(1);
+        tokio::spawn(async move {
+            Self::task_paused(file_tree, pause_receive).await;
+        });
+
+        Ok(FileSystemWatcher { state_send })
+    }
+
+    pub async fn pause(&mut self) {
+        let (send, receive) = oneshot::channel();
+        self.state_send
+            .send((StateChange::Pause, send))
+            .await
+            .unwrap();
+        receive.await.unwrap();
+    }
+
+    pub async fn unpause(&mut self) {
+        let (send, receive) = oneshot::channel();
+        self.state_send
+            .send((StateChange::Unpause, send))
+            .await
+            .unwrap();
+        receive.await.unwrap();
+    }
+
+    async fn task_paused(
+        _file_tree: Arc<Mutex<FileTree>>,
+        mut state_receive: mpsc::Receiver<(StateChange, oneshot::Sender<()>)>,
+    ) {
+        let mut paused = true;
+
+        loop {
+            if paused {
+                // If we are paused, we only need to wait for state changes.
+                let (new_state, send) = state_receive.recv().await.unwrap();
+                match new_state {
+                    StateChange::Pause => paused = true,
+                    StateChange::Unpause => paused = false,
+                    StateChange::Terminate => break, // No reply, see drop().
+                }
+                send.send(()).unwrap();
+            } else {
+                // We were unpaused, initialize the file system watcher and start waiting for
+                // that as well.
+                // TODO
+            }
+        }
+    }
+}
+
+impl Drop for FileSystemWatcher {
+    fn drop(&mut self) {
+        // The receiver is immediately dropped, so the task must not send a reply.
+        // TODO: This is racy, the task should be synchronously paused first.
+        let (send, _receive) = oneshot::channel();
+        // Here, try_send() always succeeds, because the channel always has enough capacity.
+        // pause() and unpause() are synchronous and wait until the task has emptied the channel.
+        self.state_send
+            .try_send((StateChange::Terminate, send))
+            .unwrap();
+    }
+}
+
+#[derive(Debug)]
+enum StateChange {
+    Pause,
+    Unpause,
+    Terminate,
+}

src/filetree.rs

@@ -3,8 +3,7 @@ use std::sync::Arc;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 use tokio::sync::Mutex;
 
-use super::Database;
-use super::Error;
+use super::{Database, Error};
 
 pub struct FileTree {
     db: Arc<Mutex<Database>>,

src/lib.rs

@@ -1,9 +1,11 @@
 use std::io;
 
 mod database;
+mod file_system_watcher;
 mod filetree;
 
 pub use database::Database;
+pub use file_system_watcher::FileSystemWatcher;
 pub use filetree::FileTree;
 
 // Sketch of the synchronization algorithm: