adapt for failure->anyhow migration

Author: syphar

src/docbuilder/rustwide_builder.rs

@@ -7,7 +7,6 @@ use crate::docbuilder::{crates::crates_from_path, Limits};
 use crate::error::Result;
 use crate::index::api::ReleaseData;
 use crate::repositories::RepositoryStatsUpdater;
-use crate::storage::CompressionAlgorithms;
 use crate::storage::{rustdoc_archive_path, source_archive_path};
 use crate::utils::{copy_dir_all, parse_rustc_version, CargoMetadata};
 use crate::{db::blacklist::is_blacklisted, utils::MetadataPackage};

src/storage/archive_index.rs

@@ -1,6 +1,6 @@
 use crate::error::Result;
 use crate::storage::{compression::CompressionAlgorithm, FileRange};
-use failure::ResultExt;
+use anyhow::{bail, Context as _};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 use std::io;
@@ -28,15 +28,11 @@ pub(crate) struct Index {
 
 impl Index {
     pub(crate) fn load(reader: impl io::Read) -> Result<Index> {
-        serde_cbor::from_reader(reader)
-            .context("deserialization error")
-            .map_err(Into::into)
+        serde_cbor::from_reader(reader).context("deserialization error")
     }
 
     pub(crate) fn save(&self, writer: impl io::Write) -> Result<()> {
-        serde_cbor::to_writer(writer, self)
-            .context("serialization error")
-            .map_err(Into::into)
+        serde_cbor::to_writer(writer, self).context("serialization error")
     }
 
     pub(crate) fn new_from_zip<R: io::Read + io::Seek>(zipfile: &mut R) -> Result<Index> {
@@ -56,7 +52,7 @@ impl Index {
                     ),
                     compression: match zf.compression() {
                         zip::CompressionMethod::Bzip2 => CompressionAlgorithm::Bzip2,
-                        c => failure::bail!("unsupported compression algorithm {} in zip-file", c),
+                        c => bail!("unsupported compression algorithm {} in zip-file", c),
                     },
                 },
             );

src/storage/compression.rs

@@ -1,9 +1,7 @@
 use anyhow::Error;
 use bzip2::read::{BzDecoder, BzEncoder};
 use bzip2::Compression;
-use failure::Error;
 use serde::{Deserialize, Serialize};
-use std::{collections::HashSet, fmt, io::Read};
 use std::{
     collections::HashSet,
     fmt,

src/storage/mod.rs

@@ -8,7 +8,7 @@ use self::database::DatabaseBackend;
 use self::s3::S3Backend;
 use crate::error::Result;
 use crate::{db::Pool, Config, Metrics};
-use anyhow::ensure;
+use anyhow::{anyhow, ensure};
 use chrono::{DateTime, Utc};
 use path_slash::PathExt;
 use std::{
@@ -145,7 +145,7 @@ impl Storage {
         version: &str,
         path: &str,
         archive_storage: bool,
-    ) -> Result<Blob, Error> {
+    ) -> Result<Blob> {
         Ok(if archive_storage {
             self.get_from_archive(
                 &rustdoc_archive_path(name, version),
@@ -165,7 +165,7 @@ impl Storage {
         version: &str,
         path: &str,
         archive_storage: bool,
-    ) -> Result<Blob, Error> {
+    ) -> Result<Blob> {
         Ok(if archive_storage {
             self.get_from_archive(
                 &source_archive_path(name, version),
@@ -184,7 +184,7 @@ impl Storage {
         version: &str,
         path: &str,
         archive_storage: bool,
-    ) -> Result<bool, Error> {
+    ) -> Result<bool> {
         Ok(if archive_storage {
             self.exists_in_archive(&rustdoc_archive_path(name, version), path)?
         } else {
@@ -194,7 +194,7 @@ impl Storage {
         })
     }
 
-    pub(crate) fn exists_in_archive(&self, archive_path: &str, path: &str) -> Result<bool, Error> {
+    pub(crate) fn exists_in_archive(&self, archive_path: &str, path: &str) -> Result<bool> {
         let index = self.get_index_for(archive_path)?;
         Ok(index.find_file(path).is_ok())
     }
@@ -217,7 +217,7 @@ impl Storage {
         max_size: usize,
         range: FileRange,
         compression: Option<CompressionAlgorithm>,
-    ) -> Result<Blob, Error> {
+    ) -> Result<Blob> {
         let mut blob = match &self.backend {
             StorageBackend::Database(db) => db.get(path, max_size, Some(range)),
             StorageBackend::S3(s3) => s3.get(path, max_size, Some(range)),
@@ -232,7 +232,7 @@ impl Storage {
         Ok(blob)
     }
 
-    fn get_index_for(&self, archive_path: &str) -> Result<archive_index::Index, Error> {
+    fn get_index_for(&self, archive_path: &str) -> Result<archive_index::Index> {
         // remote/folder/and/x.zip.index
         let remote_index_path = format!("{}.index", archive_path);
         let local_index_path = self
@@ -249,7 +249,7 @@ impl Storage {
             fs::create_dir_all(
                 local_index_path
                     .parent()
-                    .ok_or_else(|| err_msg("index path without parent"))?,
+                    .ok_or_else(|| anyhow!("index path without parent"))?,
             )?;
             let mut file = fs::File::create(&local_index_path)?;
             file.write_all(&index_content)?;
@@ -263,7 +263,7 @@ impl Storage {
         archive_path: &str,
         path: &str,
         max_size: usize,
-    ) -> Result<Blob, Error> {
+    ) -> Result<Blob> {
         let index = self.get_index_for(archive_path)?;
         let info = index.find_file(path)?;
 
@@ -288,7 +288,7 @@ impl Storage {
         &self,
         archive_path: &str,
         root_dir: &Path,
-    ) -> Result<(HashMap<PathBuf, String>, CompressionAlgorithm), Error> {
+    ) -> Result<(HashMap<PathBuf, String>, CompressionAlgorithm)> {
         let mut file_paths = HashMap::new();
 
         // We are only using the `zip` library to create the archives and the matching