datastore: rustfmt whole package

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

pbs-datastore/src/snapshot_reader.rs

@@ -1,7 +1,7 @@
+use std::fs::File;
+use std::os::unix::io::{AsRawFd, FromRawFd};
 use std::path::Path;
 use std::sync::Arc;
-use std::os::unix::io::{AsRawFd, FromRawFd};
-use std::fs::File;
 
 use anyhow::{bail, Error};
 use nix::dir::Dir;
@@ -9,9 +9,9 @@ use nix::dir::Dir;
 use proxmox_sys::fs::lock_dir_noblock_shared;
 
 use crate::backup_info::BackupDir;
-use crate::index::IndexFile;
-use crate::fixed_index::FixedIndexReader;
 use crate::dynamic_index::DynamicIndexReader;
+use crate::fixed_index::FixedIndexReader;
+use crate::index::IndexFile;
 use crate::manifest::{archive_type, ArchiveType, CLIENT_LOG_BLOB_NAME, MANIFEST_BLOB_NAME};
 use crate::DataStore;
 use pbs_api_types::Operation;
@@ -27,24 +27,24 @@ pub struct SnapshotReader {
 }
 
 impl SnapshotReader {
-
     /// Lock snapshot, reads the manifest and returns a new instance
     pub fn new(datastore: Arc<DataStore>, snapshot: BackupDir) -> Result<Self, Error> {
-
         let snapshot_path = datastore.snapshot_path(&snapshot);
 
-        let locked_dir = lock_dir_noblock_shared(
-            &snapshot_path,
-            "snapshot",
-            "locked by another operation")?;
+        let locked_dir =
+            lock_dir_noblock_shared(&snapshot_path, "snapshot", "locked by another operation")?;
 
         let datastore_name = datastore.name().to_string();
 
         let manifest = match datastore.load_manifest(&snapshot) {
             Ok((manifest, _)) => manifest,
             Err(err) => {
-                bail!("manifest load error on datastore '{}' snapshot '{}' - {}",
-                      datastore_name, snapshot, err);
+                bail!(
+                    "manifest load error on datastore '{}' snapshot '{}' - {}",
+                    datastore_name,
+                    snapshot,
+                    err
+                );
             }
         };
 
@@ -53,12 +53,19 @@ impl SnapshotReader {
 
         let mut file_list = Vec::new();
         file_list.push(MANIFEST_BLOB_NAME.to_string());
-        for item in manifest.files() { file_list.push(item.filename.clone()); }
+        for item in manifest.files() {
+            file_list.push(item.filename.clone());
+        }
         if client_log_path.exists() {
             file_list.push(CLIENT_LOG_BLOB_NAME.to_string());
         }
 
-        Ok(Self { snapshot, datastore_name, file_list, locked_dir })
+        Ok(Self {
+            snapshot,
+            datastore_name,
+            file_list,
+            locked_dir,
+        })
     }
 
     /// Return the snapshot directory
@@ -89,7 +96,10 @@ impl SnapshotReader {
     }
 
     /// Returns an iterator for all chunks not skipped by `skip_fn`.
-    pub fn chunk_iterator<F: Fn(&[u8;32]) -> bool>(&self, skip_fn: F) -> Result<SnapshotChunkIterator<F>, Error> {
+    pub fn chunk_iterator<F: Fn(&[u8; 32]) -> bool>(
+        &self,
+        skip_fn: F,
+    ) -> Result<SnapshotChunkIterator<F>, Error> {
         SnapshotChunkIterator::new(self, skip_fn)
     }
 }
@@ -99,14 +109,14 @@ impl SnapshotReader {
 /// Note: The iterator returns a `Result`, and the iterator state is
 /// undefined after the first error. So it make no sense to continue
 /// iteration after the first error.
-pub struct SnapshotChunkIterator<'a, F: Fn(&[u8;32]) -> bool> {
+pub struct SnapshotChunkIterator<'a, F: Fn(&[u8; 32]) -> bool> {
     snapshot_reader: &'a SnapshotReader,
     todo_list: Vec<String>,
     skip_fn: F,
     current_index: Option<(Arc<Box<dyn IndexFile + Send>>, usize, Vec<(usize, u64)>)>,
 }
 
-impl <'a, F: Fn(&[u8;32]) -> bool> Iterator for SnapshotChunkIterator<'a, F> {
+impl<'a, F: Fn(&[u8; 32]) -> bool> Iterator for SnapshotChunkIterator<'a, F> {
     type Item = Result<[u8; 32], Error>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -118,15 +128,17 @@ impl <'a, F: Fn(&[u8;32]) -> bool> Iterator for SnapshotChunkIterator<'a, F> {
                         let index: Box<dyn IndexFile + Send> = match archive_type(&filename)? {
                             ArchiveType::FixedIndex => Box::new(FixedIndexReader::new(file)?),
                             ArchiveType::DynamicIndex => Box::new(DynamicIndexReader::new(file)?),
-                            _ => bail!("SnapshotChunkIterator: got unknown file type - internal error"),
+                            _ => bail!(
+                                "SnapshotChunkIterator: got unknown file type - internal error"
+                            ),
                         };
 
-                        let datastore =
-                            DataStore::lookup_datastore(
-                                self.snapshot_reader.datastore_name(),
-                                Some(Operation::Read)
-                            )?;
-                        let order = datastore.get_chunks_in_order(&index, &self.skip_fn, |_| Ok(()))?;
+                        let datastore = DataStore::lookup_datastore(
+                            self.snapshot_reader.datastore_name(),
+                            Some(Operation::Read),
+                        )?;
+                        let order =
+                            datastore.get_chunks_in_order(&index, &self.skip_fn, |_| Ok(()))?;
 
                         self.current_index = Some((Arc::new(index), 0, order));
                     } else {
@@ -143,25 +155,29 @@ impl <'a, F: Fn(&[u8;32]) -> bool> Iterator for SnapshotChunkIterator<'a, F> {
                     // pop next index
                 }
             }
-        }).transpose()
+        })
+        .transpose()
     }
 }
 
-impl <'a, F: Fn(&[u8;32]) -> bool> SnapshotChunkIterator<'a, F> {
-
+impl<'a, F: Fn(&[u8; 32]) -> bool> SnapshotChunkIterator<'a, F> {
     pub fn new(snapshot_reader: &'a SnapshotReader, skip_fn: F) -> Result<Self, Error> {
-
         let mut todo_list = Vec::new();
 
         for filename in snapshot_reader.file_list() {
             match archive_type(filename)? {
                 ArchiveType::FixedIndex | ArchiveType::DynamicIndex => {
                     todo_list.push(filename.to_owned());
-                },
-                ArchiveType::Blob => { /* no chunks, do nothing */ },
+                }
+                ArchiveType::Blob => { /* no chunks, do nothing */ }
             }
         }
 
-        Ok(Self { snapshot_reader, todo_list, current_index: None, skip_fn })
+        Ok(Self {
+            snapshot_reader,
+            todo_list,
+            current_index: None,
+            skip_fn,
+        })
     }
 }