Convert enqueue-job bin to a new concrete error type

Author: jtgeibel

src/bin/enqueue-job.rs

@@ -1,29 +1,20 @@
-use cargo_registry::util::{cargo_err, AppError, AppResult};
-use cargo_registry::{db, env, tasks};
-use diesel::PgConnection;
+#![deny(clippy::all)]
 
-fn main() -> AppResult<()> {
+use cargo_registry::{db, env, tasks, util::Error};
+use swirl::Job;
+
+fn main() -> Result<(), Error> {
     let conn = db::connect_now()?;
     let mut args = std::env::args().skip(1);
     match &*args.next().unwrap_or_default() {
-        "update_downloads" => tasks::update_downloads().enqueue(&conn),
+        "update_downloads" => Ok(tasks::update_downloads().enqueue(&conn)?),
         "dump_db" => {
             let database_url = args.next().unwrap_or_else(|| env("DATABASE_URL"));
             let target_name = args
                 .next()
                 .unwrap_or_else(|| String::from("db-dump.tar.gz"));
-            tasks::dump_db(database_url, target_name).enqueue(&conn)
+            Ok(tasks::dump_db(database_url, target_name).enqueue(&conn)?)
         }
-        other => Err(cargo_err(&format!("Unrecognized job type `{}`", other))),
+        other => Err(Error::from(format!("Unrecognized job type `{}`", other))),
     }
 }
-
-/// Helper to map the `PerformError` returned by `swirl::Job::enqueue()` to a
-/// `AppError`. Can be removed once `map_err()` isn't needed any more.
-trait Enqueue: swirl::Job {
-    fn enqueue(self, conn: &PgConnection) -> AppResult<()> {
-        <Self as swirl::Job>::enqueue(self, conn).map_err(|e| AppError::from_std_error(e))
-    }
-}
-
-impl<J: swirl::Job> Enqueue for J {}

src/util.rs

@@ -5,8 +5,8 @@ use std::io::Cursor;
 use conduit::Response;
 use serde::Serialize;
 
-pub use self::errors::ChainError;
-pub use self::errors::{bad_request, cargo_err, internal, AppError, AppResult};
+pub use self::errors::concrete::Error;
+pub use self::errors::{bad_request, cargo_err, internal, AppError, AppResult, ChainError};
 pub use self::io_util::{read_fill, read_le_u32, LimitErrorReader};
 pub use self::request_helpers::*;
 pub use self::request_proxy::RequestProxy;

src/util/errors.rs

@@ -8,6 +8,7 @@ use diesel::result::Error as DieselError;
 
 use crate::util::json_response;
 
+pub(super) mod concrete;
 mod http;
 
 /// Returns an error with status 200 and the provided description as JSON
@@ -181,7 +182,7 @@ impl<E: Error + Send + 'static> From<E> for Box<dyn AppError> {
     }
 }
 // =============================================================================
-// Concrete errors
+// Internal error for use with `chain_error`
 
 #[derive(Debug)]
 struct InternalAppError {
@@ -201,6 +202,8 @@ impl AppError for InternalAppError {
     }
 }
 
+// TODO: The remaining can probably move under `http`
+
 #[derive(Debug, Clone, Copy)]
 pub struct NotFound;
 

src/util/errors/concrete.rs

@@ -0,0 +1,38 @@
+use std::{error, fmt};
+
+#[derive(Debug)]
+pub enum Error {
+    DbConnect(diesel::result::ConnectionError),
+    Internal(String),
+    JobEnqueue(swirl::EnqueueError),
+}
+
+impl error::Error for Error {}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::DbConnect(inner) => inner.fmt(f),
+            Error::Internal(inner) => inner.fmt(f),
+            Error::JobEnqueue(inner) => inner.fmt(f),
+        }
+    }
+}
+
+impl From<diesel::result::ConnectionError> for Error {
+    fn from(err: diesel::result::ConnectionError) -> Self {
+        Error::DbConnect(err)
+    }
+}
+
+impl From<String> for Error {
+    fn from(err: String) -> Self {
+        Error::Internal(err)
+    }
+}
+
+impl From<swirl::EnqueueError> for Error {
+    fn from(err: swirl::EnqueueError) -> Self {
+        Error::JobEnqueue(err)
+    }
+}