Create first file event handling stubs.

src/file_system_watcher.rs

+use std::collections::HashMap;
+use std::ffi::OsString;
+use std::fs;
 use std::sync::Arc;
 use std::time::Duration;
 
     }
 
     async fn handle_file_event(
-        _file_tree: &mut Arc<Mutex<FileTree>>,
+        file_tree: &mut Arc<Mutex<FileTree>>,
         errors: &mut mpsc::Sender<SynchronizationError>,
         event: FileSystemEvent,
     ) -> Result<(), Error> {
+        // When we get an I/O error, we simply ignore the corresponding file/directory. Most
+        // likely, it has been deleted, and we will get a deletion event later. If a file or
+        // directory is not readable, we do not want to synchronize it.
         match event {
             FileSystemEvent::Stopped(reason) => match reason {
                 StopReason::DirectoryRemoved => {
                     return Err(Error::DirectoryRemoved);
                 }
             },
-            FileSystemEvent::DirectoryWatched(_path) => {
-                // TODO
+            FileSystemEvent::DirectoryWatched(path) => {
+                // Fetch the directory contents as well as the database contents.
+                // TODO: We load all entries into a vector, which might be problematic for *very*
+                // large directories.
+                let fs_entries = match fs::read_dir(&path) {
+                    Ok(entries) => entries,
+                    Err(_) => return Ok(()),
+                };
+                let fs_entries = fs_entries
+                    .filter(|x| x.is_ok())
+                    .map(|x| (x.as_ref().unwrap().file_name(), x.unwrap()))
+                    .collect::<HashMap<_, _>>();
+                let db_entries = match file_tree.lock().await.get_directory_listing(&path) {
+                    Some(entries) => entries,
+                    None => return Ok(()),
+                };
+                let db_entries = db_entries
+                    .into_iter()
+                    .map(|x| (x.file_name.clone(), x))
+                    .collect::<HashMap<_, _>>();
+
+                // Compare file metadata and report changed, deleted and created files and
+                // directories.
+                for (name, _entry) in fs_entries.iter() {
+                    if db_entries.contains_key(name) {
+                        // The entry is known, compare the file attributes.
+                        // TODO
+                        // If the file attributes do not match, compare the file checksums.
+                        // TODO
+                    } else {
+                        // The file seems to be new, insert it into the database.
+                        // TODO
+                    }
+                }
+                for (name, _entry) in db_entries.iter() {
+                    if !fs_entries.contains_key(name) {
+                        // The file has been deleted, remove it from the database.
+                        // TODO
+                    }
+                }
             }
             FileSystemEvent::DirectoryCreated(_path) => {
                 // TODO
                 // TODO
             }
             FileSystemEvent::Error(e) => {
-                errors
-                    .send(SynchronizationError {
-                        needs_pause: false,
-                        error: e.into(),
-                    })
-                    .await
-                    .ok();
+                Self::send_error_no_pause(e.into(), None, errors).await;
             }
         }
 
         task::yield_now().await;
         Ok(())
     }
+
+    async fn send_error_no_pause(
+        error: Error,
+        _path: Option<OsString>,
+        errors: &mut mpsc::Sender<SynchronizationError>,
+    ) {
+        // TODO: Encode the path in the error!
+        errors
+            .send(SynchronizationError {
+                needs_pause: false,
+                error: error,
+            })
+            .await
+            .ok();
+    }
 }
 
 impl Drop for FileSystemWatcher {

src/file_tree.rs

         source
     }
 
-    pub fn get_file_info(_path: &str) -> Option<FileInfo> {
+    pub fn get_file_info(&self, _path: &OsStr) -> Option<FileInfo> {
         // TODO
         panic!("Not yet implemented.");
     }
 
-    pub fn get_directory_listing(_path: &str) -> Option<Vec<FileInfo>> {
+    pub fn get_directory_listing(&self, _path: &OsStr) -> Option<Vec<FileInfo>> {
         // TODO
         panic!("Not yet implemented.");
     }
 
-    pub fn local_file_changed(_source: NewVersionSource, _path: &str, _info: FileInfo) {
+    pub fn local_file_changed(&self, _source: NewVersionSource, _path: &OsStr, _info: FileInfo) {
         // TODO
         panic!("Not yet implemented.");
     }
 
-    pub fn local_file_removed(_source: NewVersionSource, _path: &str) {
+    pub fn local_file_removed(&self, _source: NewVersionSource, _path: &OsStr) {
         // TODO
         panic!("Not yet implemented.");
     }
 
     // TODO: Limit on size of all temporary files, make this function return a
     // future which yields a temporary file once enough space is available?
-    pub fn create_temporary_file(_target_path: &str) -> Result<TemporaryFile, Error> {
+    pub fn create_temporary_file(&self, _target_path: &OsStr) -> Result<TemporaryFile, Error> {
         // TODO
         panic!("Not yet implemented.");
     }
 
     pub fn update_file(
+        &self,
         _source: NewVersionSource,
-        _path: &str,
+        _path: &OsStr,
         _info: FileInfo,
         _contents: TemporaryFile,
         _origin: OriginInfo,
     }
 
     pub fn create_directory(
+        &self,
         _source: NewVersionSource,
-        _path: &str,
+        _path: &OsStr,
         _origin: OriginInfo,
     ) -> Result<NewVersionEvent, Error> {
         // TODO
 }
 
 pub struct FileInfo {
+    pub file_name: OsString,
     // TODO
 }