cargo fmt

src/bin/client.rs

+use std::ffi::{OsStr, OsString};
 use std::fs::{self, create_dir_all, remove_file};
 use std::sync::Arc;
-use std::ffi::{OsStr, OsString};
 
+use fslock::LockFile;
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{UnixListener, UnixStream};
 use tokio::stream::StreamExt;
 use tokio::sync::{mpsc, Mutex};
-use tokio::signal;
-use fslock::LockFile;
 
-use twfss::{Database, FileTree, ClientSideSync, FileSystemWatcher, Error, SynchronizationError, paths};
+use twfss::{
+    paths, ClientSideSync, Database, Error, FileSystemWatcher, FileTree, SynchronizationError,
+};
 
 mod cli;
 
 }
 
 impl SynchronizedDirectory {
-    async fn open(database: Arc<Mutex<Database>>, directory: &OsStr, errors: mpsc::Sender<SynchronizationError>) -> Result<SynchronizedDirectory, Error> {
+    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{
+        Ok(SynchronizedDirectory {
             path: directory.to_owned(),
             client_side_sync,
             file_system_watcher,
 
     // Initialize the existing synchronized directories.
     let mut directories = Vec::new();
-    let db = Arc::new(Mutex::new(Database::create_or_open(&paths::client_db()).unwrap()));
+    let db = Arc::new(Mutex::new(
+        Database::create_or_open(&paths::client_db()).unwrap(),
+    ));
     for directory in db.lock().await.synchronized_directories() {
         // The function cannot fail - we just fetched the directory from the database.
-        let mut sync_dir = SynchronizedDirectory::open(db.clone(), &directory, errors_send.clone()).await.unwrap();
+        let mut sync_dir = SynchronizedDirectory::open(db.clone(), &directory, errors_send.clone())
+            .await
+            .unwrap();
         sync_dir.unpause().await;
         directories.push(sync_dir);
     }
     }
 }
 
-async fn handle_cli_client(stream: &mut UnixStream, directories: &mut Vec<SynchronizedDirectory>, _db: Arc<Mutex<Database>>) -> Result<(), Error> {
+async fn handle_cli_client(
+    stream: &mut UnixStream,
+    directories: &mut Vec<SynchronizedDirectory>,
+    _db: Arc<Mutex<Database>>,
+) -> Result<(), Error> {
     let mut request = String::new();
     stream.read_to_string(&mut request).await?;
 
             // TODO
         }
         cli::Command::Pause => {
-            for  directory in directories.iter_mut() {
+            for directory in directories.iter_mut() {
                 directory.pause().await;
                 if verbose {
-                    stream.write_all(format!("Paused {}.\n", directory.path.to_string_lossy()).as_bytes()).await.ok();
+                    stream
+                        .write_all(
+                            format!("Paused {}.\n", directory.path.to_string_lossy()).as_bytes(),
+                        )
+                        .await
+                        .ok();
                 }
             }
-            stream.write_all("Synchronization paused.\n".as_bytes()).await.ok();
+            stream
+                .write_all("Synchronization paused.\n".as_bytes())
+                .await
+                .ok();
         }
         cli::Command::Resume => {
-            for  directory in directories.iter_mut() {
+            for directory in directories.iter_mut() {
                 directory.unpause().await;
                 if verbose {
-                    stream.write_all(format!("Resumed {}.\n", directory.path.to_string_lossy()).as_bytes()).await.ok();
+                    stream
+                        .write_all(
+                            format!("Resumed {}.\n", directory.path.to_string_lossy()).as_bytes(),
+                        )
+                        .await
+                        .ok();
                 }
             }
-            stream.write_all("Synchronization resumed.\n".as_bytes()).await.ok();
+            stream
+                .write_all("Synchronization resumed.\n".as_bytes())
+                .await
+                .ok();
         }
     }
 

src/client_side_sync.rs

             sync_task.task_paused(pause_receive).await;
         });
 
-        ClientSideSync{
+        ClientSideSync {
             state_send,
             new_version_source,
         }

src/network/client.rs

     where
         T: Serialize,
     {
-        let packet = Packet {
-            id,
-            payload,
-        };
+        let packet = Packet { id, payload };
         let mut serialized = Vec::new();
         packet
             .serialize(
                     assert_eq!(events.next().await, None);
                 }),
                 tokio::spawn(async move {
-                    pipe2.send(serialize_packet(SERVER_EVENT_ID, 42)).await.unwrap();
+                    pipe2
+                        .send(serialize_packet(SERVER_EVENT_ID, 42))
+                        .await
+                        .unwrap();
                     drop(pipe2);
                 }),
             );
 
             tasks.0.await.unwrap();
             tasks.1.await.unwrap();
-        }).await;
+        })
+        .await;
     }
 
     // TODO: