More CLI client code.

src/bin/client.rs

-use std::ffi::{OsStr, OsString};
+use std::ffi::OsStr;
 use std::fs::{self, create_dir_all, remove_file};
 use std::io::Write;
+use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
 use env_logger::Env;
 mod cli;
 
 struct SynchronizedDirectory {
-    path: OsString,
+    path: PathBuf,
     client_side_sync: ClientSideSync,
     file_system_watcher: FileSystemWatcher,
     last_error: Option<Error>,
         let client_side_sync = ClientSideSync::new(file_tree.clone(), errors.clone()).await;
         let file_system_watcher = FileSystemWatcher::new(file_tree, errors).await;
         Ok(SynchronizedDirectory {
-            path: directory.to_owned(),
+            path: PathBuf::from(directory),
             client_side_sync,
             file_system_watcher,
             last_error: None,
         })
     }
 
+    async fn create(
+        database: Arc<Mutex<Database>>,
+        directory: &OsStr,
+        remote_url: String,
+        errors: mpsc::Sender<SynchronizationError>,
+    ) -> Result<SynchronizedDirectory, Error> {
+        // TODO: First, connect to the server and test whether we can access the URL?
+        // At this point, the directory is still paused.
+        // TODO: Return an error if the directory is not empty (unless the user specified an
+        // override option).
+        let file_tree = Arc::new(Mutex::new(FileTree::create(
+            database, directory, remote_url,
+        )?));
+        let client_side_sync = ClientSideSync::new(file_tree.clone(), errors.clone()).await;
+        let file_system_watcher = FileSystemWatcher::new(file_tree, errors).await;
+        Ok(SynchronizedDirectory {
+            path: PathBuf::from(directory),
+            client_side_sync,
+            file_system_watcher,
+            last_error: None,
+            paused: true,
+        })
+    }
+
+    async fn remove(mut self, database: &Arc<Mutex<Database>>) -> Result<(), Error> {
+        let path = self.path.clone();
+        self.pause().await;
+        drop(self);
+
+        database
+            .lock()
+            .await
+            .remove_synchronized_directory(path.as_ref())?;
+        Ok(())
+    }
+
     async fn unpause(&mut self) {
         self.client_side_sync.unpause().await;
         self.file_system_watcher.unpause().await;
                     Some(Ok(stream)) => {
                         let mut stream = stream;
                         let mut output = Vec::new();
-                        match handle_cli_client(&mut stream, &mut output, &mut directories, db.clone()).await {
+                        match handle_cli_client(&mut stream, &mut output, &mut directories, db.clone(), &errors_send).await {
                             Ok(()) => {
                                 stream.write_all(&0i32.to_be_bytes()).await.ok();
                                 stream.write_all(&output).await.ok();
     stream: &mut UnixStream,
     output: &mut Vec<u8>,
     directories: &mut Vec<SynchronizedDirectory>,
-    _db: Arc<Mutex<Database>>,
+    db: Arc<Mutex<Database>>,
+    errors_send: &mpsc::Sender<SynchronizationError>,
 ) -> Result<(), Error> {
     let mut request = String::new();
     stream.read_to_string(&mut request).await?;
     let options: cli::Options = serde_json::from_str(&request)?;
     let verbose = options.verbose;
     match options.command {
-        _cmd @ cli::Command::ListDirectories { .. } => {
+        cli::Command::ListDirectories { status } => {
             write!(output, "{} directories\n", directories.len()).ok();
             for directory in directories.iter() {
-                write!(
-                    output,
-                    "\nDirectory: {}\nActive: {}\nLast error: {}\n",
-                    directory.path.to_string_lossy(),
-                    !directory.paused,
-                    if directory.last_error.is_some() {
-                        format!("{:?}", directory.last_error.as_ref().unwrap())
-                    } else {
-                        "None".to_owned()
-                    }
-                )
-                .ok();
+                if status {
+                    write!(
+                        output,
+                        "\nDirectory: {}\nActive: {}\nLast error: {}\n",
+                        directory.path.to_string_lossy(),
+                        !directory.paused,
+                        if directory.last_error.is_some() {
+                            format!("{:?}", directory.last_error.as_ref().unwrap())
+                        } else {
+                            "None".to_owned()
+                        }
+                    )
+                    .ok();
+                } else {
+                    write!(output, "{}\n", directory.path.to_string_lossy()).ok();
+                }
             }
         }
-        _cmd @ cli::Command::AddDirectory { .. } => {
-            // TODO
+        cli::Command::AddDirectory {
+            local_directory,
+            remote_url,
+        } => {
+            let local_directory = fs::canonicalize(local_directory)?;
+            // We need to check that we are not synchronizing directories that are within
+            // other synchronized directories.
+            for directory in directories.iter() {
+                if directory.path.starts_with(&local_directory)
+                    || local_directory.starts_with(&directory.path)
+                {
+                    return Err(Error::InvalidParam(format!(
+                        "cannot add the directory {}, as the directory {} is already synchronized.",
+                        local_directory.to_string_lossy(),
+                        directory.path.to_string_lossy()
+                    )));
+                }
+            }
+
+            let mut new_dir = SynchronizedDirectory::create(
+                db.clone(),
+                local_directory.as_os_str(),
+                remote_url,
+                errors_send.clone(),
+            )
+            .await?;
+            // We unpause if the new directory if there is at least one other unpaused directory.
+            for directory in directories.iter_mut() {
+                if !directory.paused {
+                    new_dir.unpause().await;
+                    break;
+                }
+            }
+            directories.push(new_dir);
+            write!(
+                output,
+                "Directory added: {}.\n",
+                local_directory.to_string_lossy()
+            )
+            .ok();
         }
-        _cmd @ cli::Command::RemoveDirectory { .. } => {
-            // TODO
+        cli::Command::RemoveDirectory { local_directory } => {
+            let local_directory = fs::canonicalize(local_directory)?;
+            let mut sync_dir = None;
+            for i in 0..directories.len() {
+                if local_directory == directories[i].path.as_ref() as &Path {
+                    sync_dir = Some(directories.remove(i));
+                    break;
+                }
+            }
+
+            match sync_dir {
+                Some(sync_dir) => {
+                    sync_dir.remove(&db).await?;
+                    write!(
+                        output,
+                        "Directory removed: {}.\n",
+                        local_directory.to_string_lossy()
+                    )
+                    .ok();
+                }
+                None => {
+                    write!(
+                        output,
+                        "Unknown path: {}.\n",
+                        local_directory.to_string_lossy()
+                    )
+                    .ok();
+                }
+            }
         }
         cli::Command::Pause => {
             for directory in directories.iter_mut() {

src/database.rs

 use std::ffi::OsString;
+use std::path::Path;
 
 use rusqlite::Connection;
 
         // TODO
         Vec::new()
     }
+
+    pub fn remove_synchronized_directory(&self, path: &Path) -> Result<(), crate::Error> {
+        // TODO
+        panic!("Not yet implemented.");
+    }
 }

src/file_tree.rs

         })
     }
 
+    pub fn create(
+        db: Arc<Mutex<Database>>,
+        directory: &OsStr,
+        remote_url: String,
+    ) -> Result<FileTree, Error> {
+        // TODO
+        panic!("Not yet implemented.");
+    }
+
     pub fn root_path(&self) -> &OsStr {
         &self.root_path
     }

src/lib.rs

 extern crate rmp_serde as rmps;
 
 use std::ffi::OsString;
-use std::io;
 
 use thiserror::Error;
 
     Sqlite(#[from] rusqlite::Error),
     #[error("directory removed")]
     DirectoryRemoved,
+    #[error("invalid parameter: {0}")]
+    InvalidParam(String),
 }
 
 impl From<fswatcher::Error> for Error {