clippy work

Author: marvin-j97

src/lib.rs

@@ -82,6 +82,7 @@
 #![warn(clippy::pedantic, clippy::nursery)]
 #![warn(clippy::expect_used)]
 #![allow(clippy::missing_const_for_fn)]
+#![warn(clippy::multiple_crate_versions)]
 
 mod blob_cache;
 mod compression;

src/manifest.rs

@@ -159,12 +159,12 @@ impl SegmentManifest {
         &self,
         f: F,
     ) -> crate::Result<()> {
+        let mut prev_segments = self.segments.write().expect("lock is poisoned");
+
         // NOTE: Create a copy of the levels we can operate on
         // without mutating the current level manifest
         // If persisting to disk fails, this way the level manifest
         // is unchanged
-        let mut prev_segments = self.segments.write().expect("lock is poisoned");
-
         let mut working_copy = prev_segments.clone();
 
         f(&mut working_copy);
@@ -174,6 +174,10 @@ impl SegmentManifest {
         Self::write_to_disk(&self.path, &ids)?;
         *prev_segments = working_copy;
 
+        // NOTE: Lock needs to live until end of function because
+        // writing to disk needs to be exclusive
+        drop(prev_segments);
+
         log::trace!("Swapped vLog segment list to: {ids:?}");
 
         Ok(())
@@ -215,6 +219,10 @@ impl SegmentManifest {
                             item_count: writer.item_count,
                             compressed_bytes: writer.written_blob_bytes,
                             total_uncompressed_bytes: writer.uncompressed_bytes,
+
+                            // NOTE: We are checking for 0 items above
+                            // so first and last key need to exist
+                            #[allow(clippy::expect_used)]
                             key_range: KeyRange::new((
                                 writer
                                     .first_key
@@ -336,6 +344,7 @@ impl SegmentManifest {
 
     /// Returns the percent of dead bytes (uncompressed) in the value log
     #[must_use]
+    #[allow(clippy::cast_precision_loss)]
     pub fn stale_ratio(&self) -> f32 {
         let total_bytes = self.total_bytes();
         if total_bytes == 0 {
@@ -355,6 +364,7 @@ impl SegmentManifest {
     ///
     /// Returns 0.0 if there are no items or the entire value log is stale.
     #[must_use]
+    #[allow(clippy::cast_precision_loss)]
     pub fn space_amp(&self) -> f32 {
         let total_bytes = self.total_bytes();
         if total_bytes == 0 {

src/value_log.rs

@@ -195,7 +195,6 @@ impl ValueLog {
     /// Will return `Err` if an IO error occurs.
     pub fn register_writer(&self, writer: SegmentWriter) -> crate::Result<()> {
         let _lock = self.rollover_guard.lock().expect("lock is poisoned");
-
         self.manifest.register(writer)?;
         Ok(())
     }
@@ -282,6 +281,7 @@ impl ValueLog {
     /// Tries to find a least-effort-selection of segments to
     /// merge to reach a certain space amplification.
     #[must_use]
+    #[allow(clippy::cast_precision_loss, clippy::significant_drop_tightening)]
     pub fn select_segments_for_space_amp_reduction(&self, space_amp_target: f32) -> Vec<SegmentId> {
         let current_space_amp = self.space_amp();
 
@@ -381,6 +381,7 @@ impl ValueLog {
     /// Will return `Err` if an IO error occurs.
     fn mark_as_stale(&self, ids: &[SegmentId]) {
         // NOTE: Read-locking is fine because we are dealing with an atomic bool
+        #[allow(clippy::significant_drop_tightening)]
         let segments = self.manifest.segments.read().expect("lock is poisoned");
 
         for id in ids {
@@ -401,6 +402,7 @@ impl ValueLog {
     }
 
     #[doc(hidden)]
+    #[allow(clippy::cast_precision_loss)]
     pub fn consume_scan_result(&self, segment_ids: &[u64], size_map: &SizeMap) {
         for (&id, counter) in size_map {
             let used_size = counter.size;