300 fix build warnings

CHANGELOG.md

@@ -10,6 +10,7 @@ Pearl changelog
 
 
 #### Fixed
+- Fixed build warnings (#300)
 - Fix the build by adding yanked aHash implementation (#302)
 
 #### Updated

src/blob/index/mod.rs

@@ -1,5 +1,4 @@
 use crate::{
-    prelude::*,
     storage::{BlobRecordTimestamp, ReadResult},
 };
 

src/error.rs

@@ -1,7 +1,7 @@
 use crate::prelude::*;
 
 /// The error type for `Storage` operations.
-#[derive(Debug, Error)]
+#[derive(Debug, ThisError)]
 pub struct Error {
     kind: Kind,
 }
@@ -221,4 +221,4 @@ impl IntoBincodeIfUnexpectedEofTrait for anyhow::Error {
         }
         return self;
     }
-}
+}

src/lib.rs

@@ -102,7 +102,7 @@ mod prelude {
             Arc,
         },
     };
-    pub(crate) use thiserror::Error;
+    pub(crate) use thiserror::Error as ThisError;
     pub(crate) use tokio::{
         fs::{read_dir, DirEntry},
         sync::{RwLock, Semaphore},

src/tools/blob_reader.rs

@@ -65,7 +65,7 @@ impl BlobReader {
         self.position += bincode::serialized_size(&header)?;
         header.validate().map_err(|err| {
             self.latest_wrong_header = Some(header.clone());
-            Error::record_header_validation_error(err.to_string())
+            ToolsError::record_header_validation_error(err.to_string())
         })?;
         self.latest_wrong_header = None;
 
@@ -82,7 +82,7 @@ impl BlobReader {
         let record = Record { header, meta, data };
         let record = record
             .validate()
-            .map_err(|err| Error::record_validation_error(err.to_string()))?;
+            .map_err(|err| ToolsError::record_validation_error(err.to_string()))?;
         Ok(record)
     }
 
@@ -91,14 +91,14 @@ impl BlobReader {
         let header = self
             .latest_wrong_header
             .as_ref()
-            .ok_or_else(|| Error::skip_record_data_error("wrong header not found"))?;
+            .ok_or_else(|| ToolsError::skip_record_data_error("wrong header not found"))?;
         let position = self
             .position
             .checked_add(header.data_size())
             .and_then(|x| x.checked_add(header.meta_size()))
-            .ok_or_else(|| Error::skip_record_data_error("position overflow"))?;
+            .ok_or_else(|| ToolsError::skip_record_data_error("position overflow"))?;
         if position >= self.len {
-            return Err(Error::skip_record_data_error("position is bigger than file size").into());
+            return Err(ToolsError::skip_record_data_error("position is bigger than file size").into());
         }
         self.file.seek(SeekFrom::Start(position))?;
         debug!("Skipped {} bytes", position - self.position);
@@ -113,9 +113,9 @@ impl BlobReader {
         match self.read_single_record() {
             Ok(record) => Ok(record),
             Err(error) => {
-                match error.downcast_ref::<Error>() {
-                    Some(Error::RecordValidation(_)) => {}
-                    Some(Error::RecordHeaderValidation(_)) => self.skip_wrong_record_data()?,
+                match error.downcast_ref::<ToolsError>() {
+                    Some(ToolsError::RecordValidation(_)) => {}
+                    Some(ToolsError::RecordHeaderValidation(_)) => self.skip_wrong_record_data()?,
                     _ => return Err(error),
                 }
                 warn!("Record read error, trying read next record: {}", error);

src/tools/blob_writer.rs

@@ -67,7 +67,7 @@ impl BlobWriter {
         let mut reader = BlobReader::from_file(file)?;
         let header = reader.read_header()?;
         if header != *written_header {
-            return Err(Error::blob_header_validation_error(
+            return Err(ToolsError::blob_header_validation_error(
                 "validation of written blob header failed",
             )
             .into());
@@ -97,7 +97,7 @@ impl BlobWriter {
         for record in cache.iter() {
             let written_record = reader.read_single_record()?;
             if record != &written_record {
-                return Err(Error::record_validation_error(
+                return Err(ToolsError::record_validation_error(
                     "Written and cached records is not equal",
                 )
                 .into());

src/tools/error.rs

@@ -3,7 +3,7 @@ use thiserror::Error;
 
 /// Error type
 #[derive(Debug, Error)]
-pub enum Error {
+pub enum ToolsError {
     /// Failed to validate record header
     #[error("record header validation error: {0}")]
     RecordHeaderValidation(String),
@@ -30,7 +30,7 @@ pub enum Error {
     UnsupportedKeySize(u16),
 }
 
-impl Error {
+impl ToolsError {
     pub(crate) fn record_header_validation_error(message: impl Into<String>) -> Self {
         Self::RecordHeaderValidation(message.into())
     }

src/tools/migration.rs

@@ -7,7 +7,7 @@ impl Record {
         match (source, target) {
             (source, target) if source >= target => Ok(self),
             (0, 1) => self.mirgate_v0_to_v1(),
-            (source, target) => Err(Error::unsupported_migration(source, target).into()),
+            (source, target) => Err(ToolsError::unsupported_migration(source, target).into()),
         }
     }
 
@@ -40,7 +40,7 @@ impl BlobHeader {
         match (source_version, target_version) {
             (source, target) if source >= target => Ok(self),
             (0, 1) => self.mirgate_v0_to_v1(),
-            (source, target) => Err(Error::unsupported_migration(source, target).into()),
+            (source, target) => Err(ToolsError::unsupported_migration(source, target).into()),
         }
     }
 

src/tools/utils.rs

@@ -144,7 +144,7 @@ where
             let res = index.get_records_headers(index.blob_size()).await?;
             AnyResult::<_>::Ok(res.0)
         }
-        _ => return Err(Error::index_header_validation_error("unsupported header version").into()),
+        _ => return Err(ToolsError::index_header_validation_error("unsupported header version").into()),
     }?;
     let headers = headers
         .into_iter()
@@ -163,7 +163,7 @@ pub async fn read_index(path: &Path) -> AnyResult<BTreeMap<Vec<u8>, Vec<record::
         32 => index_from_file::<ArrayKey<32>>(&header, path).await,
         64 => index_from_file::<ArrayKey<64>>(&header, path).await,
         128 => index_from_file::<ArrayKey<128>>(&header, path).await,
-        size => return Err(Error::unsupported_key_size(size).into()),
+        size => return Err(ToolsError::unsupported_key_size(size).into()),
     }?;
     for (_, headers) in headers.iter() {
         for header in headers {

src/tools/validation.rs

@@ -28,7 +28,7 @@ where
         header.blob_size()
     };
     let headers = if header.version() < HEADER_VERSION {
-        return Err(Error::index_header_validation_error(format!(
+        return Err(ToolsError::index_header_validation_error(format!(
             "Index version is outdated. Passed version: {}, latest version: {}",
             header.version(),
             HEADER_VERSION
@@ -43,7 +43,7 @@ where
             AnyResult::<_>::Ok(res.0)
         })??
     } else {
-        return Err(Error::index_header_validation_error("unknown header version").into());
+        return Err(ToolsError::index_header_validation_error("unknown header version").into());
     };
     for (_, headers) in headers {
         for header in headers {