fix: Fix a panic when calling JoinError::into_panic.

That's a lot of panics. This patch fixes a panic raised by
`JoinError:into_panic` when the `JoinError` represents a cancellation
instead of a panic.

Author: Hywan

crates/deadpool-runtime/Cargo.toml

@@ -35,3 +35,6 @@ tokio_1 = { package = "tokio", version = "1.0", features = [
     "time",
     "rt",
 ], optional = true }
+
+[dev-dependencies]
+tokio_1 = { package = "tokio", version = "1.0", features = ["rt", "macros"] }

crates/deadpool-runtime/src/lib.rs

@@ -89,9 +89,13 @@ impl Runtime {
     {
         match self {
             #[cfg(feature = "tokio_1")]
-            Self::Tokio1 => tokio_1::task::spawn_blocking(f)
-                .await
-                .map_err(|e| SpawnBlockingError::Panic(e.into_panic())),
+            Self::Tokio1 => tokio_1::task::spawn_blocking(f).await.map_err(|e| {
+                if e.is_cancelled() {
+                    SpawnBlockingError::Cancelled
+                } else {
+                    SpawnBlockingError::Panic(e.into_panic())
+                }
+            }),
             #[cfg(feature = "async-std_1")]
             #[allow(deprecated)]
             Self::AsyncStd1 => Ok(async_std_1::task::spawn_blocking(f).await),
@@ -143,14 +147,40 @@ impl Runtime {
 pub enum SpawnBlockingError {
     /// Spawned task has panicked.
     Panic(Box<dyn Any + Send + 'static>),
+
+    /// Spawned task has been cancelled.
+    Cancelled,
 }
 
 impl fmt::Display for SpawnBlockingError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Panic(p) => write!(f, "SpawnBlockingError: Panic: {:?}", p),
+            Self::Cancelled => write!(f, "SpawnBlockingError: Cancelled"),
         }
     }
 }
 
 impl std::error::Error for SpawnBlockingError {}
+
+#[cfg(all(test, feature = "tokio_1"))]
+mod tests_with_tokio_1 {
+    use super::{Runtime, SpawnBlockingError};
+
+    #[tokio_1::test(crate = "tokio_1")]
+    async fn test_spawning_blocking() {
+        assert!(Runtime::Tokio1.spawn_blocking(|| 42).await.is_ok());
+    }
+
+    #[tokio_1::test(crate = "tokio_1")]
+    async fn test_spawning_blocking_can_panic() {
+        assert!(matches!(
+            Runtime::Tokio1
+                .spawn_blocking(|| {
+                    panic!("42");
+                })
+                .await,
+            Err(SpawnBlockingError::Panic(_))
+        ));
+    }
+}

crates/deadpool-sync/src/lib.rs

@@ -54,6 +54,15 @@ impl fmt::Display for InteractError {
 
 impl std::error::Error for InteractError {}
 
+impl From<SpawnBlockingError> for InteractError {
+    fn from(value: SpawnBlockingError) -> Self {
+        match value {
+            SpawnBlockingError::Panic(p) => Self::Panic(p),
+            SpawnBlockingError::Cancelled => Self::Aborted,
+        }
+    }
+}
+
 /// Wrapper for objects which only provides blocking functions that need to be
 /// called on a separate thread.
 ///
@@ -97,6 +106,7 @@ where
             // methods needs to support a custom error enum which
             // supports a Panic variant.
             Err(SpawnBlockingError::Panic(e)) => panic!("{e:?}"),
+            Err(SpawnBlockingError::Cancelled) => panic!("Task has been cancelled"),
             Ok(obj) => obj,
         };
         result.map(|obj| Self {
@@ -127,7 +137,7 @@ where
                 Ok(f(conn))
             })
             .await
-            .map_err(|SpawnBlockingError::Panic(p)| InteractError::Panic(p))?
+            .map_err(InteractError::from)?
     }
 
     /// Indicates whether the underlying [`Mutex`] has been poisoned.