dev: located error for database

Author: da2ce7

src/databases/driver.rs

@@ -1,7 +1,30 @@
 use serde::{Deserialize, Serialize};
 
-#[derive(Serialize, Deserialize, PartialEq, Eq, Debug)]
+use super::error::Error;
+use super::mysql::Mysql;
+use super::sqlite::Sqlite;
+use super::{Builder, Database};
+
+#[derive(Serialize, Deserialize, PartialEq, Eq, Debug, derive_more::Display, Clone)]
 pub enum Driver {
     Sqlite3,
     MySQL,
 }
+
+impl Driver {
+    /// .
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if unable to connect to the database.
+    pub fn build(&self, db_path: &str) -> Result<Box<dyn Database>, Error> {
+        let database = match self {
+            Driver::Sqlite3 => Builder::<Sqlite>::build(db_path),
+            Driver::MySQL => Builder::<Mysql>::build(db_path),
+        }?;
+
+        database.create_database_tables().expect("Could not create database tables.");
+
+        Ok(database)
+    }
+}

src/databases/error.rs

@@ -1,21 +1,95 @@
-use derive_more::{Display, Error};
+use std::panic::Location;
+use std::sync::Arc;
 
-#[derive(Debug, Display, PartialEq, Eq, Error)]
-#[allow(dead_code)]
+use r2d2_mysql::mysql::UrlError;
+
+use super::driver::Driver;
+use crate::located_error::{Located, LocatedError};
+
+#[derive(thiserror::Error, Debug, Clone)]
 pub enum Error {
-    #[display(fmt = "Query returned no rows.")]
-    QueryReturnedNoRows,
-    #[display(fmt = "Invalid query.")]
-    InvalidQuery,
-    #[display(fmt = "Database error.")]
-    DatabaseError,
+    #[error("The {driver} query unexpectedly returned nothing: {source}")]
+    QueryReturnedNoRows {
+        source: LocatedError<'static, dyn std::error::Error + Send + Sync>,
+        driver: Driver,
+    },
+
+    #[error("The {driver} query was malformed: {source}")]
+    InvalidQuery {
+        source: LocatedError<'static, dyn std::error::Error + Send + Sync>,
+        driver: Driver,
+    },
+
+    #[error("Unable to insert record into {driver} database, {location}")]
+    InsertFailed {
+        location: &'static Location<'static>,
+        driver: Driver,
+    },
+
+    #[error("Failed to remove record from {driver} database, error-code: {error_code}, {location}")]
+    DeleteFailed {
+        location: &'static Location<'static>,
+        error_code: usize,
+        driver: Driver,
+    },
+
+    #[error("Failed to connect to {driver} database: {source}")]
+    ConnectionError {
+        source: LocatedError<'static, UrlError>,
+        driver: Driver,
+    },
+
+    #[error("Failed to create r2d2 {driver} connection pool: {source}")]
+    ConnectionPool {
+        source: LocatedError<'static, r2d2::Error>,
+        driver: Driver,
+    },
 }
 
 impl From<r2d2_sqlite::rusqlite::Error> for Error {
-    fn from(e: r2d2_sqlite::rusqlite::Error) -> Self {
-        match e {
-            r2d2_sqlite::rusqlite::Error::QueryReturnedNoRows => Error::QueryReturnedNoRows,
-            _ => Error::InvalidQuery,
+    #[track_caller]
+    fn from(err: r2d2_sqlite::rusqlite::Error) -> Self {
+        match err {
+            r2d2_sqlite::rusqlite::Error::QueryReturnedNoRows => Error::QueryReturnedNoRows {
+                source: (Arc::new(err) as Arc<dyn std::error::Error + Send + Sync>).into(),
+                driver: Driver::Sqlite3,
+            },
+            _ => Error::InvalidQuery {
+                source: (Arc::new(err) as Arc<dyn std::error::Error + Send + Sync>).into(),
+                driver: Driver::Sqlite3,
+            },
+        }
+    }
+}
+
+impl From<r2d2_mysql::mysql::Error> for Error {
+    #[track_caller]
+    fn from(err: r2d2_mysql::mysql::Error) -> Self {
+        let e: Arc<dyn std::error::Error + Send + Sync> = Arc::new(err);
+        Error::InvalidQuery {
+            source: e.into(),
+            driver: Driver::MySQL,
+        }
+    }
+}
+
+impl From<UrlError> for Error {
+    #[track_caller]
+    fn from(err: UrlError) -> Self {
+        Self::ConnectionError {
+            source: Located(err).into(),
+            driver: Driver::MySQL,
+        }
+    }
+}
+
+impl From<(r2d2::Error, Driver)> for Error {
+    #[track_caller]
+    fn from(e: (r2d2::Error, Driver)) -> Self {
+        let (err, driver) = e;
+        Self::ConnectionPool {
+            source: Located(err).into(),
+            driver,
         }
     }
 }

src/databases/mod.rs

@@ -3,37 +3,48 @@ pub mod error;
 pub mod mysql;
 pub mod sqlite;
 
+use std::marker::PhantomData;
+
 use async_trait::async_trait;
 
-use self::driver::Driver;
 use self::error::Error;
-use crate::databases::mysql::Mysql;
-use crate::databases::sqlite::Sqlite;
 use crate::protocol::info_hash::InfoHash;
 use crate::tracker::auth;
 
-/// # Errors
-///
-/// Will return `r2d2::Error` if `db_path` is not able to create a database.
-pub fn connect(db_driver: &Driver, db_path: &str) -> Result<Box<dyn Database>, r2d2::Error> {
-    let database: Box<dyn Database> = match db_driver {
-        Driver::Sqlite3 => {
-            let db = Sqlite::new(db_path)?;
-            Box::new(db)
-        }
-        Driver::MySQL => {
-            let db = Mysql::new(db_path)?;
-            Box::new(db)
-        }
-    };
-
-    database.create_database_tables().expect("Could not create database tables.");
-
-    Ok(database)
+pub(self) struct Builder<T>
+where
+    T: Database,
+{
+    phantom: PhantomData<T>,
+}
+
+impl<T> Builder<T>
+where
+    T: Database + 'static,
+{
+    /// .
+    ///
+    /// # Errors
+    ///
+    /// Will return `r2d2::Error` if `db_path` is not able to create a database.
+    pub(self) fn build(db_path: &str) -> Result<Box<dyn Database>, Error> {
+        Ok(Box::new(T::new(db_path)?))
+    }
 }
 
 #[async_trait]
 pub trait Database: Sync + Send {
+    /// .
+    ///
+    /// # Errors
+    ///
+    /// Will return `r2d2::Error` if `db_path` is not able to create a database.
+    fn new(db_path: &str) -> Result<Self, Error>
+    where
+        Self: std::marker::Sized;
+
+    /// .
+    ///
     /// # Errors
     ///
     /// Will return `Error` if unable to create own tables.
@@ -52,27 +63,22 @@ pub trait Database: Sync + Send {
 
     async fn save_persistent_torrent(&self, info_hash: &InfoHash, completed: u32) -> Result<(), Error>;
 
-    async fn get_info_hash_from_whitelist(&self, info_hash: &str) -> Result<InfoHash, Error>;
+    async fn get_info_hash_from_whitelist(&self, info_hash: &str) -> Result<Option<InfoHash>, Error>;
 
     async fn add_info_hash_to_whitelist(&self, info_hash: InfoHash) -> Result<usize, Error>;
 
     async fn remove_info_hash_from_whitelist(&self, info_hash: InfoHash) -> Result<usize, Error>;
 
-    async fn get_key_from_keys(&self, key: &str) -> Result<auth::Key, Error>;
+    async fn get_key_from_keys(&self, key: &str) -> Result<Option<auth::Key>, Error>;
 
     async fn add_key_to_keys(&self, auth_key: &auth::Key) -> Result<usize, Error>;
 
     async fn remove_key_from_keys(&self, key: &str) -> Result<usize, Error>;
 
     async fn is_info_hash_whitelisted(&self, info_hash: &InfoHash) -> Result<bool, Error> {
-        self.get_info_hash_from_whitelist(&info_hash.clone().to_string())
-            .await
-            .map_or_else(
-                |e| match e {
-                    Error::QueryReturnedNoRows => Ok(false),
-                    e => Err(e),
-                },
-                |_| Ok(true),
-            )
+        Ok(self
+            .get_info_hash_from_whitelist(&info_hash.clone().to_string())
+            .await?
+            .is_some())
     }
 }