Properly downcast swirl::EnqueueError

The return type of `enqueue` is `Box<dyn Error + Send + Sync>`.
Unfortunately, `Box<dyn Error>` does not implement `Error`, so our from
impl doesn't apply. We're also not able to add an explicit `From` impl
either (which is odd, coherence rules should let us write that impl).

I've opted to just add an explicit converstion function that we can use
here. We should probably check that there's nowhere else we're passing
an error object to `human` or `internal`, but that will come in a
separate PR

Author: sgrif

src/git.rs

@@ -12,7 +12,7 @@ use url::Url;
 use crate::background_jobs::Environment;
 use crate::models::{DependencyKind, Version};
 use crate::schema::versions;
-use crate::util::errors::{internal, std_error_no_send, CargoResult};
+use crate::util::errors::{std_error_no_send, CargoError, CargoResult};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Crate {
@@ -159,7 +159,9 @@ impl Job for AddCrate {
 }
 
 pub fn add_crate(conn: &PgConnection, krate: Crate) -> CargoResult<()> {
-    AddCrate { krate }.enqueue(conn).map_err(|e| internal(&e))
+    AddCrate { krate }
+        .enqueue(conn)
+        .map_err(|e| CargoError::from_std_error(e))
 }
 
 #[derive(Serialize, Deserialize)]
@@ -239,5 +241,5 @@ pub fn yank(conn: &PgConnection, krate: String, version: Version, yanked: bool)
         yanked,
     }
     .enqueue(conn)
-    .map_err(|e| internal(&e))
+    .map_err(|e| CargoError::from_std_error(e))
 }

src/util/errors.rs

@@ -49,6 +49,22 @@ impl dyn CargoError {
     pub fn is<T: Any>(&self) -> bool {
         self.get_type_id() == TypeId::of::<T>()
     }
+
+    pub fn from_std_error(err: Box<dyn Error + Send>) -> Box<dyn CargoError> {
+        Self::try_convert(&*err).unwrap_or_else(|| internal(&err))
+    }
+
+    fn try_convert(err: &(dyn Error + Send + 'static)) -> Option<Box<Self>> {
+        match err.downcast_ref() {
+            Some(DieselError::NotFound) => Some(Box::new(NotFound)),
+            Some(DieselError::DatabaseError(_, info))
+                if info.message().ends_with("read-only transaction") =>
+            {
+                Some(Box::new(ReadOnlyMode))
+            }
+            _ => None,
+        }
+    }
 }
 
 impl CargoError for Box<dyn CargoError> {
@@ -155,17 +171,9 @@ impl<E: Error + Send + 'static> CargoError for E {
     }
 }
 
-impl<E: Any + Error + Send + 'static> From<E> for Box<dyn CargoError> {
+impl<E: Error + Send + 'static> From<E> for Box<dyn CargoError> {
     fn from(err: E) -> Box<dyn CargoError> {
-        match Any::downcast_ref::<DieselError>(&err) {
-            Some(DieselError::NotFound) => Box::new(NotFound),
-            Some(DieselError::DatabaseError(_, info))
-                if info.message().ends_with("read-only transaction") =>
-            {
-                Box::new(ReadOnlyMode)
-            }
-            _ => Box::new(err),
-        }
+        CargoError::try_convert(&err).unwrap_or_else(|| Box::new(err))
     }
 }
 // =============================================================================