use custom From<anyhow::Error> for AxumNope

Author: syphar

src/utils/mod.rs

@@ -107,27 +107,9 @@ where
     F: FnOnce() -> Result<R> + Send + 'static,
     R: Send + 'static,
 {
-    let result = tokio::task::spawn_blocking(f)
+    tokio::task::spawn_blocking(f)
         .await
-        .context("failed to join thread")?;
-
-    if cfg!(debug_assertions) {
-        // Since `AxumNope` can also be silently converted into
-        // `anyhow::Error`, someone accidentally using this method
-        // instead of `web::error::spawn_blocking_web` can lead to
-        // a more specific AxumNope error with a specific status code
-        // being silently converted into an anyhow::Error, so a server
-        // error with status 500.
-        if let Err(ref err) = result {
-            use crate::web::error::AxumNope;
-            assert!(
-                err.downcast_ref::<AxumNope>().is_none(),
-                "AxumNope found inside anyhow::Error, this is likely a problem."
-            );
-        }
-    }
-
-    result
+        .context("failed to join thread")?
 }
 
 #[cfg(test)]

src/web/crate_details.rs

@@ -1,4 +1,3 @@
-use super::error::spawn_blocking_web;
 use super::{markdown, match_version, MatchSemver, MetaData};
 use crate::utils::{get_correct_docsrs_style_file, report_error, spawn_blocking};
 use crate::{
@@ -10,7 +9,7 @@ use crate::{
         error::{AxumNope, AxumResult},
     },
 };
-use anyhow::{anyhow, Context as _};
+use anyhow::anyhow;
 use axum::{
     extract::{Extension, Path},
     response::{IntoResponse, Response as AxumResponse},
@@ -326,14 +325,15 @@ pub(crate) async fn crate_details_handler(
         .into_response());
     }
 
-    let found_version = spawn_blocking_web({
+    let found_version = spawn_blocking({
         let pool = pool.clone();
         let params = params.clone();
         move || {
-            let mut conn = pool.get().context("could not get connection from pool")?;
-            match_version(&mut conn, &params.name, params.version.as_deref())
-                .and_then(|m| m.assume_exact())
-                .map_err(Into::<AxumNope>::into)
+            let mut conn = pool.get()?;
+            Ok(
+                match_version(&mut conn, &params.name, params.version.as_deref())
+                    .and_then(|m| m.assume_exact())?,
+            )
         }
     })
     .await?;

src/web/error.rs

@@ -4,7 +4,6 @@ use crate::{
     db::PoolError,
     web::{page::WebPage, releases::Search, AxumErrorPage, ErrorPage},
 };
-use anyhow::Context as _;
 use axum::{
     http::StatusCode,
     response::{IntoResponse, Response as AxumResponse},
@@ -157,7 +156,7 @@ pub enum AxumNope {
     #[error("Internal server error")]
     InternalServerError,
     #[error("internal error")]
-    InternalError(#[from] anyhow::Error),
+    InternalError(anyhow::Error),
 }
 
 impl IntoResponse for AxumNope {
@@ -235,6 +234,18 @@ impl IntoResponse for AxumNope {
     }
 }
 
+impl From<anyhow::Error> for AxumNope {
+    fn from(err: anyhow::Error) -> Self {
+        match err.downcast::<AxumNope>() {
+            Ok(axum_nope) => axum_nope,
+            Err(err) => match err.downcast::<Nope>() {
+                Ok(iron_nope) => AxumNope::from(iron_nope),
+                Err(err) => AxumNope::InternalError(err),
+            },
+        }
+    }
+}
+
 impl From<Nope> for AxumNope {
     fn from(err: Nope) -> Self {
         match err {
@@ -251,44 +262,6 @@ impl From<Nope> for AxumNope {
 
 pub(crate) type AxumResult<T> = Result<T, AxumNope>;
 
-/// spawn-blocking helper for usage in axum requests.
-///
-/// Should be used when spawning tasks from inside web-handlers
-/// that return AxumNope as error. The join-error will also be
-/// converted into an `anyhow::Error`. Any standard AxumNope
-/// will be left intact so the error-handling can generate the
-/// correct status-page with the correct status code.
-///
-/// Examples:
-///
-/// with standard `tokio::task::spawn_blocking`:
-/// ```ignore
-/// let data = spawn_blocking(move || -> Result<_, AxumNope> {
-///     let data = get_the_data()?;
-///     Ok(data)
-/// })
-/// .await
-/// .context("failed to join thread")??;
-/// ```
-///
-/// with this helper function:
-/// ```ignore
-/// let data = spawn_blocking(move || {
-///     let data = get_the_data()?;
-///     Ok(data)
-/// })
-/// .await?
-/// ```
-pub(crate) async fn spawn_blocking_web<F, R>(f: F) -> AxumResult<R>
-where
-    F: FnOnce() -> AxumResult<R> + Send + 'static,
-    R: Send + 'static,
-{
-    tokio::task::spawn_blocking(f)
-        .await
-        .context("failed to join thread")?
-}
-
 #[cfg(test)]
 mod tests {
     use crate::test::wrapper;