more results

Signed-off-by: simonsan <[email protected]>

Author: simonsan

crates/core/src/blob/packer.rs

@@ -521,6 +521,7 @@ impl<BE: DecryptWriteBackend> RawPacker<BE> {
         if self.has(id) {
             return Ok(());
         }
+
         self.stats.blobs += 1;
         self.stats.data += data_len;
         let data_len_packed: u64 = data
@@ -726,8 +727,14 @@ impl Actor {
     fn finalize(self) -> RusticResult<()> {
         // cancel channel
         drop(self.sender);
+
         // wait for items in channel to be processed
-        self.finish.recv().unwrap()
+        let _ = self
+            .finish
+            .recv()
+            .map_err(PackerErrorKind::ReceivingCrossbeamMessageFailedForActorFinalizing)?;
+
+        Ok(())
     }
 }
 
@@ -805,13 +812,15 @@ impl<BE: DecryptFullBackend> Repacker<BE> {
                 blob.length,
             )
             .map_err(RusticErrorKind::Backend)?;
+
         self.packer.add_raw(
             &data,
             &blob.id,
             0,
             blob.uncompressed_length,
             Some(self.size_limit),
         )?;
+
         Ok(())
     }
 
@@ -835,8 +844,10 @@ impl<BE: DecryptFullBackend> Repacker<BE> {
             blob.length,
             blob.uncompressed_length,
         )?;
+
         self.packer
             .add_with_sizelimit(data, blob.id, Some(self.size_limit))?;
+
         Ok(())
     }
 

crates/core/src/commands/prune.rs

@@ -1165,22 +1165,31 @@ impl PrunePlan {
         if !self.existing_packs.is_empty() {
             if opts.instant_delete {
                 let p = pb.progress_counter("removing unindexed packs...");
+
                 let existing_packs: Vec<_> = self.existing_packs.into_keys().collect();
+
                 be.delete_list(FileType::Pack, true, existing_packs.iter(), p)?;
             } else {
                 let p =
                     pb.progress_counter("marking unneeded unindexed pack files for deletion...");
-                p.set_length(self.existing_packs.len().try_into().unwrap());
+
+                p.set_length(u64::try_from(self.existing_packs.len()).map_err(|_| {
+                    CommandErrorKind::TooManyPacksToDelete(self.existing_packs.len())
+                })?);
+
                 for (id, size) in self.existing_packs {
                     let pack = IndexPack {
                         id,
                         size: Some(size),
                         time: Some(Local::now()),
                         blobs: Vec::new(),
                     };
+
                     indexer.write().add_remove(pack)?;
+
                     p.inc(1);
                 }
+
                 p.finish();
             }
         }

crates/core/src/commands/restore.rs

@@ -25,7 +25,7 @@ use crate::{
         FileType, ReadBackend,
     },
     blob::BlobType,
-    error::{CommandErrorKind, RusticErrorKind, RusticResult},
+    error::{CommandErrorKind, IgnoreErrorKind, RusticErrorKind, RusticResult},
     id::Id,
     progress::{Progress, ProgressBars},
     repository::{IndexedFull, IndexedTree, Open, Repository},
@@ -313,7 +313,11 @@ impl RestoreOptions {
                                         )
                                     })?
                                     .is_dir())
-                                || (node.is_file() && !destination.metadata().unwrap().is_file())
+                                || (node.is_file()
+                                    && !destination
+                                        .metadata()
+                                        .map_err(IgnoreErrorKind::GenericError)?
+                                        .is_file())
                                 || node.is_special()
                             {
                                 // if types do not match, first remove the existing file
@@ -369,20 +373,20 @@ impl RestoreOptions {
                     if path.starts_with(stack_path) {
                         break;
                     }
-                    self.set_metadata(dest, stack_path, stack_node);
+                    self.set_metadata(dest, stack_path, stack_node)?;
                     _ = dir_stack.pop();
                 }
 
                 // push current path to the stack
                 dir_stack.push((path, node));
             } else {
-                self.set_metadata(dest, &path, &node);
+                self.set_metadata(dest, &path, &node)?;
             }
         }
 
         // empty dir stack and set metadata
         for (path, node) in dir_stack.into_iter().rev() {
-            self.set_metadata(dest, &path, &node);
+            self.set_metadata(dest, &path, &node)?;
         }
 
         Ok(())
@@ -399,26 +403,57 @@ impl RestoreOptions {
     /// # Errors
     ///
     /// If the metadata could not be set.
-    // TODO: Return a result here, introduce errors and get rid of logging.
-    fn set_metadata(self, dest: &LocalDestination, path: &PathBuf, node: &Node) {
+    fn set_metadata(
+        self,
+        dest: &LocalDestination,
+        path: &PathBuf,
+        node: &Node,
+    ) -> RusticResult<()> {
         debug!("setting metadata for {:?}", path);
-        dest.create_special(path, node)
-            .unwrap_or_else(|_| warn!("restore {:?}: creating special file failed.", path));
+
+        let mut errors = vec![];
+
+        if let Err(err) = dest.create_special(path, node) {
+            debug!("restore {:?}: creating special file failed.", path);
+            errors.push(err);
+        }
+
         match (self.no_ownership, self.numeric_id) {
             (true, _) => {}
-            (false, true) => dest
-                .set_uid_gid(path, &node.meta)
-                .unwrap_or_else(|_| warn!("restore {:?}: setting UID/GID failed.", path)),
-            (false, false) => dest
-                .set_user_group(path, &node.meta)
-                .unwrap_or_else(|_| warn!("restore {:?}: setting User/Group failed.", path)),
+            (false, true) => {
+                if let Err(err) = dest.set_uid_gid(path, &node.meta) {
+                    debug!("restore {:?}: setting UID/GID failed.", path);
+                    errors.push(err);
+                }
+            }
+            (false, false) => {
+                if let Err(err) = dest.set_user_group(path, &node.meta) {
+                    debug!("restore {:?}: setting User/Group failed.", path);
+                    errors.push(err);
+                }
+            }
         }
-        dest.set_permission(path, node)
-            .unwrap_or_else(|_| warn!("restore {:?}: chmod failed.", path));
-        dest.set_extended_attributes(path, &node.meta.extended_attributes)
-            .unwrap_or_else(|_| warn!("restore {:?}: setting extended attributes failed.", path));
-        dest.set_times(path, &node.meta)
-            .unwrap_or_else(|_| warn!("restore {:?}: setting file times failed.", path));
+
+        if let Err(err) = dest.set_permission(path, node) {
+            debug!("restore {:?}: chmod failed.", path);
+            errors.push(err);
+        };
+
+        if let Err(err) = dest.set_extended_attributes(path, &node.meta.extended_attributes) {
+            debug!("restore {:?}: setting extended attributes failed.", path);
+            errors.push(err);
+        };
+
+        if let Err(err) = dest.set_times(path, &node.meta) {
+            debug!("restore {:?}: setting file times failed.", path);
+            errors.push(err);
+        };
+
+        if !errors.is_empty() {
+            return Err(CommandErrorKind::ErrorSettingMetadata(path.clone(), errors).into());
+        }
+
+        Ok(())
     }
 }
 

crates/core/src/error.rs

@@ -234,6 +234,10 @@ pub enum CommandErrorKind {
         #[source]
         source: OutOfRangeError,
     },
+    /// There are too many packs to delete: `{0}`
+    TooManyPacksToDelete(usize),
+    /// error setting metadata for {0:?}: {1:?}
+    ErrorSettingMetadata(PathBuf, Vec<RusticError>),
 }
 
 /// [`CryptoErrorKind`] describes the errors that can happen while dealing with Cryptographic functions
@@ -508,6 +512,8 @@ pub enum PackerErrorKind {
     FileWriterHandleNotPresent,
     /// failed to receive message for PackerStats: `{0:?}`
     ReceivingCrossbeamMessageFailedForPackerStats(crossbeam_channel::RecvError),
+    /// failed to receive message: `{0:?}`
+    ReceivingCrossbeamMessageFailedForActorFinalizing(crossbeam_channel::RecvError),
 }
 
 /// [`TreeErrorKind`] describes the errors that can come up dealing with Trees