client: Initialize synchronized directories from the database.

All the backend code is still missing.

src/bin/client.rs

 use std::fs::create_dir_all;
-use std::io;
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
+use std::ffi::OsStr;
 
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{UnixListener, UnixStream};
 use tokio::stream::StreamExt;
+use tokio::sync::{mpsc, Mutex};
 
-use twfss::Database;
+use twfss::{Database, FileTree, ClientSideSync, FileSystemWatcher, Error, SynchronizationError};
 
 mod cli;
 
     format!("{}/client.db", data_dir())
 }
 
+struct SynchronizedDirectory {
+    client_side_sync: ClientSideSync,
+    file_system_watcher: FileSystemWatcher,
+}
+
+impl SynchronizedDirectory {
+    async fn open(database: Arc<Mutex<Database>>, directory: &OsStr, errors: mpsc::Sender<SynchronizationError>) -> Result<SynchronizedDirectory, Error> {
+        let file_tree = Arc::new(Mutex::new(FileTree::open(database, directory)?));
+        let client_side_sync = ClientSideSync::new(file_tree.clone(), errors.clone()).await?;
+        let file_system_watcher = FileSystemWatcher::new(file_tree, errors).await?;
+        Ok(SynchronizedDirectory{
+            client_side_sync,
+            file_system_watcher,
+        })
+    }
+
+    async fn unpause(&mut self) {
+        self.client_side_sync.unpause().await;
+        self.file_system_watcher.unpause().await;
+    }
+
+    async fn pause(&mut self) {
+        self.client_side_sync.pause().await;
+        self.file_system_watcher.pause().await;
+    }
+}
+
 #[tokio::main]
 async fn main() {
     // Create the data directories if necessary.
 
     // TODO: Register signal handler for graceful shutdown.
 
+    // TODO: Error handling. If a directory was removed, remove it from the
+    // list of synchronized directories (or mark it for the user).
+    let (errors_send, errors) = mpsc::channel(32);
+
     // Initialize the existing synchronized directories.
-    //let mut directories = Vec::new();
-    let _db = Arc::new(Mutex::new(Database::create_or_open(&db_path()).unwrap()));
-    /*for directory in db.lock().unwrap().synchronized_directories() {
-        // TODO: Error handling. If the directory was removed, remove it from the
-        // list of synchronized directories.
-        directories.push(SynchronizedDirectory::open(db.clone(), &directory, false).unwrap());
-    }*/
+    let mut directories = Vec::new();
+    let db = Arc::new(Mutex::new(Database::create_or_open(&db_path()).unwrap()));
+    for directory in db.lock().await.synchronized_directories() {
+        // TODO: Error handling - remove the synchronized directory instead (or mark it for the
+        // user).
+        let mut sync_dir = SynchronizedDirectory::open(db.clone(), &directory, errors_send.clone()).await.unwrap();
+        sync_dir.unpause().await;
+        directories.push(sync_dir);
+    }
 
     // Listen for CLI commands.
     // TODO: Graceful shutdown on errors.
     Ok(())
 }
 
-#[derive(Debug)]
-enum Error {
-    Json(serde_json::error::Error),
-    Io(std::io::Error),
-}
-
-impl From<serde_json::error::Error> for Error {
-    fn from(e: serde_json::error::Error) -> Error {
-        Error::Json(e)
-    }
-}
-
-impl From<io::Error> for Error {
-    fn from(e: io::Error) -> Error {
-        Error::Io(e)
-    }
-}

src/database.rs

+use std::ffi::OsString;
+
 pub struct Database {
     // TODO
 }
         Ok(Database {})
     }
 
-    pub fn synchronized_directories(&self) -> Vec<String> {
+    pub fn synchronized_directories(&self) -> Vec<OsString> {
         // TODO
         Vec::new()
     }

src/lib.rs

+//! Library for file-system synchronization.
 extern crate rmp_serde as rmps;
 
 use std::io;
 #[derive(Debug)]
 pub enum Error {
     Io(std::io::Error),
+    Json(serde_json::error::Error),
     DirectoryRemoved,
 }
 
+impl From<serde_json::error::Error> for Error {
+    fn from(e: serde_json::error::Error) -> Error {
+        Error::Json(e)
+    }
+}
+
 impl From<io::Error> for Error {
     fn from(e: io::Error) -> Error {
         Error::Io(e)