Move SQL errors into their own module

src/sql.rs

@@ -1,5 +1,7 @@
 //! # SQLite wrapper
 
+use failure::Fail;
+
 use std::collections::HashSet;
 use std::sync::{Arc, RwLock};
 use std::time::Duration;
@@ -11,10 +13,53 @@ use crate::chat::update_saved_messages_icon;
 use crate::constants::ShowEmails;
 use crate::context::Context;
 use crate::dc_tools::*;
-use crate::error::{Error, Result};
 use crate::param::*;
 use crate::peerstate::*;
 
+#[derive(Debug, Fail)]
+pub enum Error {
+    #[fail(display = "Sqlite Error: {:?}", _0)]
+    Sql(#[cause] rusqlite::Error),
+    #[fail(display = "Sqlite Connection Pool Error: {:?}", _0)]
+    ConnectionPool(#[cause] r2d2::Error),
+    #[fail(display = "Sqlite: Connection closed")]
+    SqlNoConnection,
+    #[fail(display = "Sqlite: Already open")]
+    SqlAlreadyOpen,
+    #[fail(display = "Sqlite: Failed to open")]
+    SqlFailedToOpen,
+    #[fail(display = "{:?}", _0)]
+    Io(#[cause] std::io::Error),
+    #[fail(display = "{:?}", _0)]
+    BlobError(#[cause] crate::blob::BlobError),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl From<rusqlite::Error> for Error {
+    fn from(err: rusqlite::Error) -> Error {
+        Error::Sql(err)
+    }
+}
+
+impl From<r2d2::Error> for Error {
+    fn from(err: r2d2::Error) -> Error {
+        Error::ConnectionPool(err)
+    }
+}
+
+impl From<std::io::Error> for Error {
+    fn from(err: std::io::Error) -> Error {
+        Error::Io(err)
+    }
+}
+
+impl From<crate::blob::BlobError> for Error {
+    fn from(err: crate::blob::BlobError) -> Error {
+        Error::BlobError(err)
+    }
+}
+
 /// A wrapper around the underlying Sqlite3 object.
 #[derive(DebugStub)]
 pub struct Sql {
@@ -47,7 +92,7 @@ impl Sql {
     pub fn open(&self, context: &Context, dbfile: &std::path::Path, readonly: bool) -> bool {
         match open(context, self, dbfile, readonly) {
             Ok(_) => true,
-            Err(Error::SqlAlreadyOpen) => false,
+            Err(crate::error::Error::SqlError(Error::SqlAlreadyOpen)) => false,
             Err(_) => {
                 self.close(context);
                 false
@@ -321,14 +366,14 @@ fn open(
     sql: &Sql,
     dbfile: impl AsRef<std::path::Path>,
     readonly: bool,
-) -> Result<()> {
+) -> crate::error::Result<()> {
     if sql.is_open() {
         error!(
             context,
             "Cannot open, database \"{:?}\" already opened.",
             dbfile.as_ref(),
         );
-        return Err(Error::SqlAlreadyOpen);
+        return Err(Error::SqlAlreadyOpen.into());
     }
 
     let mut open_flags = OpenFlags::SQLITE_OPEN_NO_MUTEX;
@@ -345,7 +390,8 @@ fn open(
         .min_idle(Some(2))
         .max_size(10)
         .connection_timeout(std::time::Duration::new(60, 0))
-        .build(mgr)?;
+        .build(mgr)
+        .map_err(Error::ConnectionPool)?;
 
     {
         *sql.pool.write().unwrap() = Some(pool);
@@ -477,7 +523,7 @@ fn open(
                     dbfile.as_ref(),
                 );
                 // cannot create the tables - maybe we cannot write?
-                return Err(Error::SqlFailedToOpen);
+                return Err(Error::SqlFailedToOpen.into());
             } else {
                 sql.set_raw_config_int(context, "dbversion", 0)?;
             }