From 3ff271ba93b5632377d9b6e1b6b318cb6d24f245 Mon Sep 17 00:00:00 2001
From: Simon Laux <mobile.info@simonlaux.de>
Date: Thu, 10 Oct 2024 15:11:46 +0200
Subject: [PATCH] name remaining blocking tasks

---
 deltachat-repl/src/main.rs |  3 +--
 src/key.rs                 |  9 ++++----
 src/pgp.rs                 | 42 ++++++++++++++++++--------------------
 3 files changed, 26 insertions(+), 28 deletions(-)

diff --git a/deltachat-repl/src/main.rs b/deltachat-repl/src/main.rs
index 3a326d4de..72f7f0f60 100644
--- a/deltachat-repl/src/main.rs
+++ b/deltachat-repl/src/main.rs
@@ -353,9 +353,8 @@ async fn start(args: Vec<String>) -> Result<(), Error> {
 
             match readline {
                 Ok(line) => {
-                    // TODO: ignore "set mail_pw"
                     rl.add_history_entry(line.as_str())?;
-                    let should_continue = Handle::current().block_on(async {
+                    let should_continue = spawn_named_blocking_task!("repl:handle_cmd", async {
                         match handle_cmd(line.trim(), ctx.clone(), &mut selected_chat).await {
                             Ok(ExitResult::Continue) => true,
                             Ok(ExitResult::Exit) => {
diff --git a/src/key.rs b/src/key.rs
index 846e8d096..f95554530 100644
--- a/src/key.rs
+++ b/src/key.rs
@@ -12,13 +12,13 @@ use pgp::composed::Deserializable;
 pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
 use pgp::ser::Serialize;
 use pgp::types::{KeyTrait, SecretKeyTrait};
-use tokio::runtime::Handle;
 
 use crate::config::Config;
 use crate::constants::KeyGenType;
 use crate::context::Context;
 use crate::log::LogExt;
 use crate::pgp::KeyPair;
+use crate::spawn_named_blocking_task;
 use crate::tools::{self, time_elapsed};
 
 /// Convenience trait for working with keys.
@@ -251,9 +251,10 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
             let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType).await?)
                 .unwrap_or_default();
             info!(context, "Generating keypair with type {}", keytype);
-            // TODO? add it here as well?
-            let keypair = Handle::current()
-                .spawn_blocking(move || crate::pgp::create_keypair(addr, keytype))
+            let keypair =
+                spawn_named_blocking_task!("generate_keypair", move || crate::pgp::create_keypair(
+                    addr, keytype
+                ))
                 .await??;
 
             store_self_keypair(context, &keypair, KeyPairUse::Default).await?;
diff --git a/src/pgp.rs b/src/pgp.rs
index 20176e8ba..e86cb7e84 100644
--- a/src/pgp.rs
+++ b/src/pgp.rs
@@ -251,34 +251,32 @@ pub async fn pk_encrypt(
 ) -> Result<String> {
     let lit_msg = Message::new_literal_bytes("", plain);
 
-    // TODO? label this
-    Handle::current()
-        .spawn_blocking(move || {
-            let pkeys: Vec<SignedPublicKeyOrSubkey> = public_keys_for_encryption
-                .iter()
-                .filter_map(select_pk_for_encryption)
-                .collect();
-            let pkeys_refs: Vec<&SignedPublicKeyOrSubkey> = pkeys.iter().collect();
+    spawn_named_blocking_task("pk_encrypt", move || {
+        let pkeys: Vec<SignedPublicKeyOrSubkey> = public_keys_for_encryption
+            .iter()
+            .filter_map(select_pk_for_encryption)
+            .collect();
+        let pkeys_refs: Vec<&SignedPublicKeyOrSubkey> = pkeys.iter().collect();
 
-            let mut rng = thread_rng();
+        let mut rng = thread_rng();
 
-            let encrypted_msg = if let Some(ref skey) = private_key_for_signing {
-                let signed_msg = lit_msg.sign(skey, || "".into(), HASH_ALGORITHM)?;
-                let compressed_msg = if compress {
-                    signed_msg.compress(CompressionAlgorithm::ZLIB)?
-                } else {
-                    signed_msg
-                };
-                compressed_msg.encrypt_to_keys(&mut rng, SYMMETRIC_KEY_ALGORITHM, &pkeys_refs)?
+        let encrypted_msg = if let Some(ref skey) = private_key_for_signing {
+            let signed_msg = lit_msg.sign(skey, || "".into(), HASH_ALGORITHM)?;
+            let compressed_msg = if compress {
+                signed_msg.compress(CompressionAlgorithm::ZLIB)?
             } else {
-                lit_msg.encrypt_to_keys(&mut rng, SYMMETRIC_KEY_ALGORITHM, &pkeys_refs)?
+                signed_msg
             };
+            compressed_msg.encrypt_to_keys(&mut rng, SYMMETRIC_KEY_ALGORITHM, &pkeys_refs)?
+        } else {
+            lit_msg.encrypt_to_keys(&mut rng, SYMMETRIC_KEY_ALGORITHM, &pkeys_refs)?
+        };
 
-            let encoded_msg = encrypted_msg.to_armored_string(Default::default())?;
+        let encoded_msg = encrypted_msg.to_armored_string(Default::default())?;
 
-            Ok(encoded_msg)
-        })
-        .await?
+        Ok(encoded_msg)
+    })
+    .await?
 }
 
 /// Signs `plain` text using `private_key_for_signing`.