typo fixes all over the place

Signed-off-by: Thomas Lamprecht <t.lamprecht@proxmox.com>

src/tools/broadcast_future.rs

@@ -149,14 +149,14 @@ fn test_broadcast_future() {
         .map_ok(|res| {
             CHECKSUM.fetch_add(res, Ordering::SeqCst);
         })
-        .map_err(|err| { panic!("got errror {}", err); })
+        .map_err(|err| { panic!("got error {}", err); })
         .map(|_| ());
 
     let receiver2 = sender.listen()
         .map_ok(|res| {
             CHECKSUM.fetch_add(res*2, Ordering::SeqCst);
         })
-        .map_err(|err| { panic!("got errror {}", err); })
+        .map_err(|err| { panic!("got error {}", err); })
         .map(|_| ());
 
     let mut rt = tokio::runtime::Runtime::new().unwrap();

src/tools/file_logger.rs

@@ -4,7 +4,7 @@ use std::io::Write;
 
 /// Log messages with timestamps into files
 ///
-/// Logs messages to file, and optionaly to standart output.
+/// Logs messages to file, and optionally to standard output.
 ///
 ///
 /// #### Example:

src/tools/fs.rs

@@ -107,7 +107,7 @@ pub fn read_subdir<P: ?Sized + nix::NixPath>(dirfd: RawFd, path: &P) -> nix::Res
 }
 
 /// Scan through a directory with a regular expression. This is simply a shortcut filtering the
-/// results of `read_subdir`. Non-UTF8 comaptible file names are silently ignored.
+/// results of `read_subdir`. Non-UTF8 compatible file names are silently ignored.
 pub fn scan_subdir<'a, P: ?Sized + nix::NixPath>(
     dirfd: RawFd,
     path: &P,

src/tools/process_locker.rs

@@ -1,6 +1,6 @@
 //! Inter-process reader-writer lock builder.
 //!
-//! This implemenation uses fcntl record locks with non-blocking
+//! This implementation uses fcntl record locks with non-blocking
 //! F_SETLK command (never blocks).
 //!
 //! We maintain a map of shared locks with time stamps, so you can get
@@ -127,9 +127,9 @@ impl ProcessLocker {
         Ok(())
     }
 
-    /// Try to aquire a shared lock
+    /// Try to acquire a shared lock
     ///
-    /// On sucess, this makes sure that no other process can get an exclusive lock for the file.
+    /// On success, this makes sure that no other process can get an exclusive lock for the file.
     pub fn try_shared_lock(locker: Arc<Mutex<Self>>) -> Result<ProcessLockSharedGuard, Error> {
 
         let mut data = locker.lock().unwrap();
@@ -168,7 +168,7 @@ impl ProcessLocker {
         result
     }
 
-    /// Try to aquire a exclusive lock
+    /// Try to acquire a exclusive lock
     ///
     /// Make sure the we are the only process which has locks for this file (shared or exclusive).
     pub fn try_exclusive_lock(locker: Arc<Mutex<Self>>) -> Result<ProcessLockExclusiveGuard, Error> {

src/tools/ticket.rs

@@ -1,4 +1,4 @@
-//! Generate and verify Authentification tickets
+//! Generate and verify Authentication tickets
 
 use anyhow::{bail, Error};
 use base64;