revert partial

src/build_queue.rs

@@ -5,7 +5,7 @@ use crate::error::Result;
 use crate::storage::Storage;
 use crate::utils::{get_config, get_crate_priority, report_error, retry, set_config, ConfigName};
 use crate::Context;
-use crate::{BuildPackageError, Config, Index, InstanceMetrics, RustwideBuilder};
+use crate::{Config, Index, InstanceMetrics, RustwideBuilder};
 use anyhow::Context as _;
 use fn_error_context::context;
 use std::collections::HashMap;

src/docbuilder/mod.rs

@@ -3,4 +3,4 @@ mod rustwide_builder;
 
 pub(crate) use self::limits::Limits;
 pub(crate) use self::rustwide_builder::DocCoverage;
-pub use self::rustwide_builder::{BuildPackageError, PackageKind, RustwideBuilder};
+pub use self::rustwide_builder::{PackageKind, RustwideBuilder};

src/docbuilder/rustwide_builder.rs

@@ -80,14 +80,6 @@ pub enum PackageKind<'a> {
     Registry(&'a str),
 }
 
-#[derive(Debug, thiserror::Error)]
-pub enum BuildPackageError {
-    #[error("error before build: {0:?}")]
-    PreBuildError(#[source] anyhow::Error),
-    #[error("internal build error: {0:?}")]
-    InternalError(#[source] anyhow::Error),
-}
-
 pub struct RustwideBuilder {
     workspace: Workspace,
     toolchain: Toolchain,
@@ -345,11 +337,7 @@ impl RustwideBuilder {
                 err.context(format!("failed to load local package {}", path.display()))
             })?;
         let package = metadata.root();
-        match self.build_package(&package.name, &package.version, PackageKind::Local(path)) {
-            Ok(build_result) => Ok(build_result),
-            Err(BuildPackageError::PreBuildError(err)) => Err(err),
-            Err(BuildPackageError::InternalError(err)) => Err(err),
-        }
+        Ok(self.build_package(&package.name, &package.version, PackageKind::Local(path))?)
     }
 
     #[instrument(name = "docbuilder.build_package", parent = None, skip(self, name), fields(krate=name))]
@@ -358,17 +346,14 @@ impl RustwideBuilder {
         name: &str,
         version: &str,
         kind: PackageKind<'_>,
-    ) -> Result<bool, BuildPackageError> {
-        let build_id = self
-            .runtime
-            .block_on(async {
-                let mut conn = self.db.get_async().await?;
-                let crate_id = initialize_crate(&mut conn, name).await?;
-                let release_id = initialize_release(&mut conn, crate_id, version).await?;
-                let build_id = initialize_build(&mut conn, release_id).await?;
-                Ok::<i32, Error>(build_id)
-            })
-            .map_err(BuildPackageError::InternalError)?;
+    ) -> Result<bool> {
+        let build_id = self.runtime.block_on(async {
+            let mut conn = self.db.get_async().await?;
+            let crate_id = initialize_crate(&mut conn, name).await?;
+            let release_id = initialize_release(&mut conn, crate_id, version).await?;
+            let build_id = initialize_build(&mut conn, release_id).await?;
+            Ok::<i32, Error>(build_id)
+        })?;
 
         match self.build_package_inner(name, version, kind, build_id) {
             Ok(successful) => Ok(successful),
@@ -377,17 +362,11 @@ impl RustwideBuilder {
                 // result.
                 // At some point we might introduce a special error type which additionally reports
                 // to sentry.
-                let mut conn = self
-                    .db
-                    .get_async()
-                    .await
-                    .map_err(|err| BuildPackageError::InternalError(err.into()))?;
+                let mut conn = self.db.get_async().await?;
 
-                update_build_with_error(&mut conn, build_id, Some(&format!("{:?}", err)))
-                    .await
-                    .map_err(|err| BuildPackageError::InternalError(err.into()))?;
+                update_build_with_error(&mut conn, build_id, Some(&format!("{:?}", err))).await?;
 
-                Err(BuildPackageError::PreBuildError(err))
+                Ok(false)
             }),
         }
     }

src/lib.rs

@@ -6,7 +6,7 @@ pub use self::build_queue::BuildQueue;
 pub use self::config::Config;
 pub use self::context::Context;
 pub use self::docbuilder::PackageKind;
-pub use self::docbuilder::{BuildPackageError, RustwideBuilder};
+pub use self::docbuilder::RustwideBuilder;
 pub use self::index::Index;
 pub use self::metrics::{InstanceMetrics, ServiceMetrics};
 pub use self::registry_api::RegistryApi;