Merge pull request #1915 from deltachat/resultify-sqy-open

Resultify sql.open()

src/context.rs

@@ -136,10 +136,7 @@ impl Context {
         let ctx = Context {
             inner: Arc::new(inner),
         };
-        ensure!(
+        ctx.sql.open(&ctx, &ctx.dbfile, false).await?;
-            ctx.sql.open(&ctx, &ctx.dbfile, false).await,
-            "Failed opening sqlite database"
-        );
 
         Ok(ctx)
     }

src/imex.rs

@@ -6,6 +6,7 @@ use std::{
     ffi::OsStr,
 };
 
+use anyhow::Context as _;
 use async_std::path::{Path, PathBuf};
 use async_std::{
     fs::{self, File},
@@ -94,7 +95,8 @@ pub async fn imex(
             }
             Err(err) => {
                 cleanup_aborted_imex(context, what).await;
-                error!(context, "{}", err);
+                // We are using Anyhow's .context() and to show the inner error, too, we need the {:#}:
+                error!(context, "{:#}", err);
                 context.emit_event(EventType::ImexProgress(0));
                 bail!("IMEX FAILED to complete: {}", err);
             }
@@ -118,7 +120,9 @@ async fn cleanup_aborted_imex(context: &Context, what: ImexMode) {
         dc_delete_files_in_dir(context, context.get_blobdir()).await;
     }
     if what == ImexMode::ExportBackup || what == ImexMode::ImportBackup {
-        context.sql.open(context, context.get_dbfile(), false).await;
+        if let Err(e) = context.sql.open(context, context.get_dbfile(), false).await {
+            warn!(context, "Re-opening db after imex failed: {}", e);
+        }
     }
 }
 
@@ -166,17 +170,23 @@ pub async fn has_backup_old(context: &Context, dir_name: impl AsRef<Path>) -> Re
             let name = name.to_string_lossy();
             if name.starts_with("delta-chat") && name.ends_with(".bak") {
                 let sql = Sql::new();
-                if sql.open(context, &path, true).await {
+                match sql.open(context, &path, true).await {
-                    let curr_backup_time = sql
+                    Ok(_) => {
-                        .get_raw_config_int(context, "backup_time")
+                        let curr_backup_time = sql
-                        .await
+                            .get_raw_config_int(context, "backup_time")
-                        .unwrap_or_default();
+                            .await
-                    if curr_backup_time > newest_backup_time {
+                            .unwrap_or_default();
-                        newest_backup_path = Some(path);
+                        if curr_backup_time > newest_backup_time {
-                        newest_backup_time = curr_backup_time;
+                            newest_backup_path = Some(path);
+                            newest_backup_time = curr_backup_time;
+                        }
+                        info!(context, "backup_time of {} is {}", name, curr_backup_time);
+                        sql.close().await;
                     }
-                    info!(context, "backup_time of {} is {}", name, curr_backup_time);
+                    Err(e) => warn!(
-                    sql.close().await;
+                        context,
+                        "Found backup file {} which could not be opened: {}", name, e
+                    ),
                 }
             }
         }
@@ -520,13 +530,11 @@ async fn import_backup(context: &Context, backup_to_import: impl AsRef<Path>) ->
         }
     }
 
-    ensure!(
+    context
-        context
+        .sql
-            .sql
+        .open(&context, &context.get_dbfile(), false)
-            .open(&context, &context.get_dbfile(), false)
+        .await
-            .await,
+        .context("Could not re-open db")?;
-        "could not re-open db"
-    );
 
     delete_and_reset_all_device_msgs(&context).await?;
 
@@ -558,13 +566,11 @@ async fn import_backup_old(context: &Context, backup_to_import: impl AsRef<Path>
     );
     /* error already logged */
     /* re-open copied database file */
-    ensure!(
+    context
-        context
+        .sql
-            .sql
+        .open(&context, &context.get_dbfile(), false)
-            .open(&context, &context.get_dbfile(), false)
+        .await
-            .await,
+        .context("Could not re-open db")?;
-        "could not re-open db"
-    );
 
     delete_and_reset_all_device_msgs(&context).await?;
 
@@ -743,7 +749,7 @@ async fn export_backup_old(context: &Context, dir: impl AsRef<Path>) -> Result<(
     context
         .sql
         .open(&context, &context.get_dbfile(), false)
-        .await;
+        .await?;
 
     if !copied {
         bail!(
@@ -753,11 +759,11 @@ async fn export_backup_old(context: &Context, dir: impl AsRef<Path>) -> Result<(
         );
     }
     let dest_sql = Sql::new();
-    ensure!(
+    dest_sql
-        dest_sql.open(context, &dest_path_filename, false).await,
+        .open(context, &dest_path_filename, false)
-        "could not open exported database {}",
+        .await
-        dest_path_string
+        .with_context(|| format!("could not open exported database {}", dest_path_string))?;
-    );
+
     let res = match add_files_to_export(context, &dest_sql).await {
         Err(err) => {
             dc_delete_file(context, &dest_path_filename).await;

src/sql.rs

@@ -14,6 +14,7 @@ use crate::constants::{ShowEmails, DC_CHAT_ID_TRASH};
 use crate::context::Context;
 use crate::dc_tools::*;
 use crate::ephemeral::start_ephemeral_timers;
+use crate::error::format_err;
 use crate::param::*;
 use crate::peerstate::*;
 
@@ -77,18 +78,29 @@ impl Sql {
         // drop closes the connection
     }
 
-    // return true on success, false on failure
+    pub async fn open<T: AsRef<Path>>(
-    pub async fn open<T: AsRef<Path>>(&self, context: &Context, dbfile: T, readonly: bool) -> bool {
+        &self,
-        match open(context, self, dbfile, readonly).await {
+        context: &Context,
-            Ok(_) => true,
+        dbfile: T,
-            Err(err) => match err.downcast_ref::<Error>() {
+        readonly: bool,
-                Some(Error::SqlAlreadyOpen) => false,
+    ) -> crate::error::Result<()> {
+        let res = open(context, self, &dbfile, readonly).await;
+        if let Err(err) = &res {
+            match err.downcast_ref::<Error>() {
+                Some(Error::SqlAlreadyOpen) => {}
                 _ => {
                     self.close().await;
-                    false
                 }
-            },
+            }
         }
+        res.map_err(|e| {
+            format_err!(
+                // We are using Anyhow's .context() and to show the inner error, too, we need the {:#}:
+                "Could not open db file {}: {:#}",
+                dbfile.as_ref().to_string_lossy(),
+                e
+            )
+        })
     }
 
     pub async fn execute<S: AsRef<str>>(