4 files changed, 239 insertions, 270 deletions

diff --git a/src/core/function/gpg/GpgAdvancedOperator.cpp b/src/core/function/gpg/GpgAdvancedOperator.cpp
index 14202942..c338e69a 100644
--- a/src/core/function/gpg/GpgAdvancedOperator.cpp
+++ b/src/core/function/gpg/GpgAdvancedOperator.cpp
@@ -40,50 +40,53 @@ GpgFrontend::GpgAdvancedOperator::GpgAdvancedOperator(int channel)
 
 bool GpgFrontend::GpgAdvancedOperator::ClearGpgPasswordCache() {
   bool success = false;
-  GpgFrontend::GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().GpgConfPath, {"--reload", "gpg-agent"},
-      [&](int exit_code, const std::string &p_out, const std::string &p_err) {
-        if (exit_code == 0) {
-          SPDLOG_DEBUG("gpgconf reload exit code: {}", exit_code);
-          success = true;
-        }
-      });
+  GpgFrontend::GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().GpgConfPath,
+       {"--reload", "gpg-agent"},
+       [&](int exit_code, const std::string &p_out, const std::string &p_err) {
+         if (exit_code == 0) {
+           SPDLOG_DEBUG("gpgconf reload exit code: {}", exit_code);
+           success = true;
+         }
+       }});
   return success;
 }
 
 bool GpgFrontend::GpgAdvancedOperator::ReloadGpgComponents() {
   bool success = false;
-  GpgFrontend::GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().GpgConfPath, {"--reload"},
-      [&](int exit_code, const std::string &p_out, const std::string &p_err) {
-        if (exit_code == 0) {
-          success = true;
-        } else {
-          SPDLOG_ERROR(
-              "gpgconf execute error, process stderr: {}, process stdout: {}",
-              p_err, p_out);
-          return;
-        }
-      });
+  GpgFrontend::GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().GpgConfPath,
+       {"--reload"},
+       [&](int exit_code, const std::string &p_out, const std::string &p_err) {
+         if (exit_code == 0) {
+           success = true;
+         } else {
+           SPDLOG_ERROR(
+               "gpgconf execute error, process stderr: {}, process stdout: {}",
+               p_err, p_out);
+           return;
+         }
+       }});
   return success;
 }
 
 bool GpgFrontend::GpgAdvancedOperator::RestartGpgComponents() {
   bool success = false;
 
-  GpgFrontend::GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().GpgConfPath, {"--verbose", "--kill", "all"},
-      [&](int exit_code, const std::string &p_out, const std::string &p_err) {
-        if (exit_code == 0) {
-          success = true;
-          return;
-        } else {
-          SPDLOG_ERROR(
-              "gpgconf execute error, process stderr: {}, process stdout: {}",
-              p_err, p_out);
-          return;
-        }
-      });
+  GpgFrontend::GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().GpgConfPath,
+       {"--verbose", "--kill", "all"},
+       [&](int exit_code, const std::string &p_out, const std::string &p_err) {
+         if (exit_code == 0) {
+           success = true;
+           return;
+         } else {
+           SPDLOG_ERROR(
+               "gpgconf execute error, process stderr: {}, process stdout: {}",
+               p_err, p_out);
+           return;
+         }
+       }});
 
   if (!success) return false;
 
@@ -98,87 +101,89 @@ bool GpgFrontend::GpgAdvancedOperator::RestartGpgComponents() {
 
 bool GpgFrontend::GpgAdvancedOperator::ResetConfigures() {
   bool success = false;
-  GpgFrontend::GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().GpgConfPath, {"--apply-defaults"},
-      [&](int exit_code, const std::string &p_out, const std::string &p_err) {
-        if (exit_code == 0) {
-          success = true;
-        } else {
-          SPDLOG_ERROR(
-              "gpgconf execute error, process stderr: {}, process stdout: {}",
-              p_err, p_out);
-          return;
-        }
-      });
+  GpgFrontend::GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().GpgConfPath,
+       {"--apply-defaults"},
+       [&](int exit_code, const std::string &p_out, const std::string &p_err) {
+         if (exit_code == 0) {
+           success = true;
+         } else {
+           SPDLOG_ERROR(
+               "gpgconf execute error, process stderr: {}, process stdout: {}",
+               p_err, p_out);
+           return;
+         }
+       }});
 
   return success;
 }
 
 bool GpgFrontend::GpgAdvancedOperator::StartGpgAgent() {
   bool success = false;
-  GpgFrontend::GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().GpgAgentPath,
-      {"--homedir", ctx_.GetInfo().GnuPGHomePath, "--daemon"},
-      [&](int exit_code, const std::string &p_out, const std::string &p_err) {
-        if (exit_code == 0) {
-          success = true;
-          SPDLOG_INFO("start gpg-agent successfully");
-        } else if (exit_code == 2) {
-          success = true;
-          SPDLOG_INFO("gpg-agent already started");
-        } else {
-          SPDLOG_ERROR(
-              "gpg-agent execute error, process stderr: {}, process stdout: {}",
-              p_err, p_out);
-          return;
-        }
-      });
+  GpgFrontend::GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().GpgAgentPath,
+       {"--homedir", ctx_.GetInfo().GnuPGHomePath, "--daemon"},
+       [&](int exit_code, const std::string &p_out, const std::string &p_err) {
+         if (exit_code == 0) {
+           success = true;
+           SPDLOG_INFO("start gpg-agent successfully");
+         } else if (exit_code == 2) {
+           success = true;
+           SPDLOG_INFO("gpg-agent already started");
+         } else {
+           SPDLOG_ERROR(
+               "gpg-agent execute error, process stderr: {}, process stdout: "
+               "{}",
+               p_err, p_out);
+           return;
+         }
+       }});
 
   return success;
 }
 
 bool GpgFrontend::GpgAdvancedOperator::StartDirmngr() {
   bool success = false;
-  GpgFrontend::GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().DirmngrPath,
-      {"--homedir", ctx_.GetInfo().GnuPGHomePath, "--daemon"},
-      [&](int exit_code, const std::string &p_out, const std::string &p_err) {
-        if (exit_code == 0) {
-          success = true;
-          SPDLOG_INFO("start dirmngr successfully");
-        } else if (exit_code == 2) {
-          success = true;
-          SPDLOG_INFO("dirmngr already started");
-        } else {
-          SPDLOG_ERROR(
-              "dirmngr execute error, process stderr: {}, process stdout: {}",
-              p_err, p_out);
-          return;
-        }
-      });
+  GpgFrontend::GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().DirmngrPath,
+       {"--homedir", ctx_.GetInfo().GnuPGHomePath, "--daemon"},
+       [&](int exit_code, const std::string &p_out, const std::string &p_err) {
+         if (exit_code == 0) {
+           success = true;
+           SPDLOG_INFO("start dirmngr successfully");
+         } else if (exit_code == 2) {
+           success = true;
+           SPDLOG_INFO("dirmngr already started");
+         } else {
+           SPDLOG_ERROR(
+               "dirmngr execute error, process stderr: {}, process stdout: {}",
+               p_err, p_out);
+           return;
+         }
+       }});
 
   return success;
 }
 
 bool GpgFrontend::GpgAdvancedOperator::StartKeyBoxd() {
   bool success = false;
-  GpgFrontend::GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().KeyboxdPath,
-      {"--homedir", ctx_.GetInfo().GnuPGHomePath, "--daemon"},
-      [&](int exit_code, const std::string &p_out, const std::string &p_err) {
-        if (exit_code == 0) {
-          success = true;
-          SPDLOG_INFO("start keyboxd successfully");
-        } else if (exit_code == 2) {
-          success = true;
-          SPDLOG_INFO("keyboxd already started");
-        } else {
-          SPDLOG_ERROR(
-              "keyboxd execute error, process stderr: {}, process stdout: {}",
-              p_err, p_out);
-          return;
-        }
-      });
+  GpgFrontend::GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().KeyboxdPath,
+       {"--homedir", ctx_.GetInfo().GnuPGHomePath, "--daemon"},
+       [&](int exit_code, const std::string &p_out, const std::string &p_err) {
+         if (exit_code == 0) {
+           success = true;
+           SPDLOG_INFO("start keyboxd successfully");
+         } else if (exit_code == 2) {
+           success = true;
+           SPDLOG_INFO("keyboxd already started");
+         } else {
+           SPDLOG_ERROR(
+               "keyboxd execute error, process stderr: {}, process stdout: {}",
+               p_err, p_out);
+           return;
+         }
+       }});
 
   return success;
 }
diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp
index 2fee2be6..2e453388 100644
--- a/src/core/function/gpg/GpgCommandExecutor.cpp
+++ b/src/core/function/gpg/GpgCommandExecutor.cpp
@@ -34,134 +34,86 @@
 #include "core/thread/TaskRunnerGetter.h"
 #include "thread/DataObject.h"
 
-GpgFrontend::GpgCommandExecutor::GpgCommandExecutor(int channel)
-    : SingletonFunctionObject<GpgCommandExecutor>(channel) {}
-
-void GpgFrontend::GpgCommandExecutor::Execute(
-    std::string cmd, std::vector<std::string> arguments,
-    GpgCommandExecutorCallback callback,
-    GpgCommandExecutorInteractor interact_func) {
-  SPDLOG_DEBUG("called cmd {} arguments size: {}", cmd, arguments.size());
-
-  Thread::Task::TaskCallback result_callback =
-      [](int rtn, Thread::DataObjectPtr data_object) {
-        SPDLOG_DEBUG("data object use count: {}", data_object->GetObjectSize());
-        if (!data_object->Check<int, std::string, std::string,
-                                GpgCommandExecutorCallback>())
-          throw std::runtime_error("invalid data object size");
-
-        auto exit_code = Thread::ExtractParams<int>(data_object, 0);
-        auto process_stdout =
-            Thread::ExtractParams<std::string>(data_object, 1);
-        auto process_stderr =
-            Thread::ExtractParams<std::string>(data_object, 2);
-        auto callback =
-            Thread::ExtractParams<GpgCommandExecutorCallback>(data_object, 3);
-
-        // call callback
-        callback(exit_code, process_stdout, process_stderr);
-      };
-
-  Thread::Task::TaskRunnable runner =
-      [](Thread::DataObjectPtr data_object) -> int {
-    SPDLOG_DEBUG("process runner called, data object size: {}",
-                 data_object->GetObjectSize());
-
-    if (!data_object->Check<std::string, std::vector<std::string>,
-                            GpgCommandExecutorInteractor,
-                            GpgCommandExecutorCallback>())
-      throw std::runtime_error("invalid data object size");
+namespace GpgFrontend {
 
-    // get arguments
-    auto cmd = Thread::ExtractParams<std::string>(data_object, 0);
-    SPDLOG_DEBUG("get cmd: {}", cmd);
-    auto arguments =
-        Thread::ExtractParams<std::vector<std::string>>(data_object, 1);
-    auto interact_func =
-        Thread::ExtractParams<GpgCommandExecutorInteractor>(data_object, 2);
-    auto callback =
-        Thread::ExtractParams<GpgCommandExecutorCallback>(data_object, 3);
-
-    auto *cmd_process = new QProcess();
-    cmd_process->setProcessChannelMode(QProcess::MergedChannels);
-
-    QObject::connect(cmd_process, &QProcess::started,
-                     []() -> void { SPDLOG_DEBUG("process started"); });
-    QObject::connect(
-        cmd_process, &QProcess::readyReadStandardOutput,
-        [interact_func, cmd_process]() { interact_func(cmd_process); });
-    QObject::connect(cmd_process, &QProcess::errorOccurred,
-                     [=](QProcess::ProcessError error) {
-                       SPDLOG_ERROR("error in executing command: {} error: {}",
-                                    cmd, error);
-                     });
-    QObject::connect(
-        cmd_process, qOverload<int, QProcess::ExitStatus>(&QProcess::finished),
-        [=](int, QProcess::ExitStatus status) {
-          if (status == QProcess::NormalExit)
-            SPDLOG_DEBUG(
-                "proceess finished, succeed in executing command: {}, exit "
-                "status: {}",
-                cmd, status);
-          else
-            SPDLOG_ERROR(
-                "proceess finished, error in executing command: {}, exit "
-                "status: {}",
-                cmd, status);
-        });
+GpgCommandExecutor::GpgCommandExecutor(int channel)
+    : SingletonFunctionObject<GpgCommandExecutor>(channel) {}
 
-    cmd_process->setProgram(QString::fromStdString(cmd));
+void GpgCommandExecutor::ExecuteSync(ExecuteContext context) {
+  Thread::Task *task = build_task(context);
+  QEventLoop looper;
+  QObject::connect(task, &Thread::Task::SignalTaskEnd, &looper,
+                   &QEventLoop::quit);
 
-    QStringList q_arguments;
-    for (const auto &argument : arguments)
-      q_arguments.append(QString::fromStdString(argument));
-    cmd_process->setArguments(q_arguments);
+  GpgFrontend::Thread::TaskRunnerGetter::GetInstance()
+      .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_External_Process)
+      ->PostTask(task);
 
-    SPDLOG_DEBUG("process execute ready, cmd: {} {}", cmd,
-                 q_arguments.join(" ").toStdString());
+  // block until task finished
+  // this is to keep reference vaild until task finished
+  looper.exec();
+}
 
-    cmd_process->start();
-    cmd_process->waitForFinished();
+void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) {
+  for (auto &context : contexts) {
+    auto &cmd = context.cmd;
+    auto &arguments = context.arguments;
+    auto &interact_func = context.interact_func;
+    auto &callback = context.callback;
+
+    SPDLOG_INFO("gpg concurrently called cmd {}", cmd);
+
+    Thread::Task *task = build_task(context);
+    GpgFrontend::Thread::TaskRunnerGetter::GetInstance()
+        .GetTaskRunner(
+            Thread::TaskRunnerGetter::kTaskRunnerType_External_Process)
+        ->PostTask(task);
+  }
+}
 
-    std::string process_stdout =
-                    cmd_process->readAllStandardOutput().toStdString(),
-                process_stderr =
-                    cmd_process->readAllStandardError().toStdString();
-    int exit_code = cmd_process->exitCode();
+void GpgCommandExecutor::ExecuteConcurrentlySync(
+    const ExecuteContexts contexts) {
+  QEventLoop looper;
+  int remainingTasks = contexts.size();
 
-    cmd_process->close();
-    cmd_process->deleteLater();
+  for (auto &context : contexts) {
+    auto &cmd = context.cmd;
+    auto &arguments = context.arguments;
+    auto &interact_func = context.interact_func;
+    auto &callback = context.callback;
 
-    data_object->Swap({exit_code, process_stdout, process_stderr, callback});
-    return 0;
-  };
+    SPDLOG_INFO("gpg concurrently called cmd {}", cmd);
 
-  auto *process_task = new GpgFrontend::Thread::Task(
-      std::move(runner), fmt::format("Execute/{}", cmd),
-      Thread::TransferParams(cmd, arguments, interact_func, callback),
-      std::move(result_callback));
+    Thread::Task *task = build_task(context);
 
-  QEventLoop looper;
-  QObject::connect(process_task, &Thread::Task::SignalTaskEnd, &looper,
-                   &QEventLoop::quit);
+    QObject::connect(task, &Thread::Task::SignalTaskEnd, [&]() {
+      --remainingTasks;
+      if (remainingTasks <= 0) {
+        looper.quit();
+      }
+    });
 
-  GpgFrontend::Thread::TaskRunnerGetter::GetInstance()
-      .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_External_Process)
-      ->PostTask(process_task);
+    GpgFrontend::Thread::TaskRunnerGetter::GetInstance()
+        .GetTaskRunner(
+            Thread::TaskRunnerGetter::kTaskRunnerType_External_Process)
+        ->PostConcurrentTask(task);
+  }
 
-  // block until task finished
-  // this is to keep reference vaild until task finished
   looper.exec();
 }
 
-void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently(
-    std::string cmd, std::vector<std::string> arguments,
-    GpgCommandExecutorCallback callback,
-    GpgCommandExecutorInteractor interact_func) {
-  SPDLOG_DEBUG("called cmd {} arguments size: {}", cmd, arguments.size());
+Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) {
+  auto &cmd = context.cmd;
+  auto &arguments = context.arguments;
+  auto &interact_function = context.interact_func;
+  auto &callback = context.callback;
+
+  SPDLOG_DEBUG("building task: called cmd {} arguments size: {}", cmd,
+               arguments.size());
 
   Thread::Task::TaskCallback result_callback =
       [](int rtn, Thread::DataObjectPtr data_object) {
+        SPDLOG_DEBUG("data object use count: {}", data_object->GetObjectSize());
         if (!data_object->Check<int, std::string, std::string,
                                 GpgCommandExecutorCallback>())
           throw std::runtime_error("invalid data object size");
@@ -179,7 +131,7 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently(
       };
 
   Thread::Task::TaskRunnable runner =
-      [](GpgFrontend::Thread::DataObjectPtr data_object) -> int {
+      [](Thread::DataObjectPtr data_object) -> int {
     SPDLOG_DEBUG("process runner called, data object size: {}",
                  data_object->GetObjectSize());
 
@@ -190,10 +142,11 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently(
 
     // get arguments
     auto cmd = Thread::ExtractParams<std::string>(data_object, 0);
+    SPDLOG_DEBUG("get cmd: {}", cmd);
     auto arguments =
         Thread::ExtractParams<std::vector<std::string>>(data_object, 1);
     auto interact_func =
-        Thread::ExtractParams<std::function<void(QProcess *)>>(data_object, 2);
+        Thread::ExtractParams<GpgCommandExecutorInteractor>(data_object, 2);
     auto callback =
         Thread::ExtractParams<GpgCommandExecutorCallback>(data_object, 3);
 
@@ -226,14 +179,13 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently(
         });
 
     cmd_process->setProgram(QString::fromStdString(cmd));
-    cmd_process->setProcessChannelMode(QProcess::SeparateChannels);
 
     QStringList q_arguments;
     for (const auto &argument : arguments)
       q_arguments.append(QString::fromStdString(argument));
     cmd_process->setArguments(q_arguments);
 
-    SPDLOG_DEBUG("process start ready, cmd: {} {}", cmd,
+    SPDLOG_DEBUG("process execute ready, cmd: {} {}", cmd,
                  q_arguments.join(" ").toStdString());
 
     cmd_process->start();
@@ -252,16 +204,10 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently(
     return 0;
   };
 
-  // data transfer into task
-  auto data_object =
-      Thread::TransferParams(cmd, arguments, interact_func, callback);
-
-  auto *process_task = new GpgFrontend::Thread::Task(
-      std::move(runner), fmt::format("ExecuteConcurrently/{}", cmd),
-      data_object, std::move(result_callback), false);
-  process_task->HoldOnLifeCycle(true);
-
-  GpgFrontend::Thread::TaskRunnerGetter::GetInstance()
-      .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_External_Process)
-      ->PostTask(process_task);
+  return new Thread::Task(
+      std::move(runner), fmt::format("Execute/{}", cmd),
+      Thread::TransferParams(cmd, arguments, interact_function, callback),
+      std::move(result_callback));
 }
+
+}  // namespace GpgFrontend
\ No newline at end of file
diff --git a/src/core/function/gpg/GpgCommandExecutor.h b/src/core/function/gpg/GpgCommandExecutor.h
index 1bad6d40..98167269 100644
--- a/src/core/function/gpg/GpgCommandExecutor.h
+++ b/src/core/function/gpg/GpgCommandExecutor.h
@@ -29,6 +29,7 @@
 #ifndef GPGFRONTEND_ZH_CN_TS_GPGCOMMANDEXECUTOR_H
 #define GPGFRONTEND_ZH_CN_TS_GPGCOMMANDEXECUTOR_H
 
+#include <initializer_list>
 #ifndef WINDOWS
 #include <boost/process.hpp>
 #endif
@@ -50,6 +51,25 @@ using GpgCommandExecutorInteractor = std::function<void(QProcess *)>;
 class GPGFRONTEND_CORE_EXPORT GpgCommandExecutor
     : public SingletonFunctionObject<GpgCommandExecutor> {
  public:
+  struct ExecuteContext {
+    const std::string cmd;
+    const std::vector<std::string> arguments;
+    const GpgCommandExecutorCallback callback;
+    const GpgCommandExecutorInteractor interact_func;
+
+    ExecuteContext(
+        std::string cmd, std::vector<std::string> arguments,
+        GpgCommandExecutorCallback callback = [](int, std::string,
+                                                 std::string) {},
+        GpgCommandExecutorInteractor interact_func = [](QProcess *) {})
+        : cmd(cmd),
+          arguments(arguments),
+          callback(callback),
+          interact_func(interact_func) {}
+  };
+
+  using ExecuteContexts = std::vector<ExecuteContext>;
+
   /**
    * @brief Construct a new Gpg Command Executor object
    *
@@ -64,20 +84,17 @@ class GPGFRONTEND_CORE_EXPORT GpgCommandExecutor
    * @param arguments Command parameters
    * @param interact_func Command answering function
    */
-  void Execute(
-      std::string cmd, std::vector<std::string> arguments,
-      GpgCommandExecutorCallback callback = [](int, std::string,
-                                               std::string) {},
-      GpgCommandExecutorInteractor interact_func = [](QProcess *) {});
+  void ExecuteSync(ExecuteContext);
 
-  void ExecuteConcurrently(
-      std::string cmd, std::vector<std::string> arguments,
-      GpgCommandExecutorCallback callback,
-      GpgCommandExecutorInteractor interact_func = [](QProcess *) {});
+  void ExecuteConcurrentlyAsync(ExecuteContexts);
+
+  void ExecuteConcurrentlySync(ExecuteContexts);
 
  private:
   GpgContext &ctx_ = GpgContext::GetInstance(
       SingletonFunctionObject::GetChannel());  ///< Corresponding context
+
+  Thread::Task *build_task(const ExecuteContext &);
 };
 
 }  // namespace GpgFrontend
diff --git a/src/core/function/gpg/GpgKeyOpera.cpp b/src/core/function/gpg/GpgKeyOpera.cpp
index cc87fd4b..bdce3831 100644
--- a/src/core/function/gpg/GpgKeyOpera.cpp
+++ b/src/core/function/gpg/GpgKeyOpera.cpp
@@ -105,45 +105,46 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::SetExpire(
 void GpgFrontend::GpgKeyOpera::GenerateRevokeCert(
     const GpgKey& key, const std::string& output_file_path) {
   // get all components
-  GpgCommandExecutor::GetInstance().Execute(
-      ctx_.GetInfo().AppPath,
-      {"--command-fd", "0", "--status-fd", "1", "--no-tty", "-o",
-       output_file_path, "--gen-revoke", key.GetFingerprint().c_str()},
-      [=](int exit_code, const std::string& p_out, const std::string& p_err) {
-        if (exit_code != 0) {
-          SPDLOG_ERROR(
-              "gnupg gen revoke execute error, process stderr: {}, process "
-              "stdout: {}",
-              p_err, p_out);
-        } else {
-          SPDLOG_DEBUG(
-              "gnupg gen revoke exit_code: {}, process stdout size: {}",
-              exit_code, p_out.size());
-        }
-      },
-      [](QProcess* proc) -> void {
-        // Code From Gpg4Win
-        while (proc->canReadLine()) {
-          const QString line = QString::fromUtf8(proc->readLine()).trimmed();
-          SPDLOG_DEBUG("line: {}", line.toStdString());
-          if (line == QLatin1String("[GNUPG:] GET_BOOL gen_revoke.okay")) {
-            proc->write("y\n");
-          } else if (line == QLatin1String("[GNUPG:] GET_LINE "
-                                           "ask_revocation_reason.code")) {
-            proc->write("0\n");
-          } else if (line == QLatin1String("[GNUPG:] GET_LINE "
-                                           "ask_revocation_reason.text")) {
-            proc->write("\n");
-          } else if (line == QLatin1String(
-                                 "[GNUPG:] GET_BOOL openfile.overwrite.okay")) {
-            // We asked before
-            proc->write("y\n");
-          } else if (line == QLatin1String("[GNUPG:] GET_BOOL "
-                                           "ask_revocation_reason.okay")) {
-            proc->write("y\n");
-          }
-        }
-      });
+  GpgCommandExecutor::GetInstance().ExecuteSync(
+      {ctx_.GetInfo().AppPath,
+       {"--command-fd", "0", "--status-fd", "1", "--no-tty", "-o",
+        output_file_path, "--gen-revoke", key.GetFingerprint().c_str()},
+       [=](int exit_code, const std::string& p_out, const std::string& p_err) {
+         if (exit_code != 0) {
+           SPDLOG_ERROR(
+               "gnupg gen revoke execute error, process stderr: {}, process "
+               "stdout: {}",
+               p_err, p_out);
+         } else {
+           SPDLOG_DEBUG(
+               "gnupg gen revoke exit_code: {}, process stdout size: {}",
+               exit_code, p_out.size());
+         }
+       },
+       [](QProcess* proc) -> void {
+         // Code From Gpg4Win
+         while (proc->canReadLine()) {
+           const QString line = QString::fromUtf8(proc->readLine()).trimmed();
+           SPDLOG_DEBUG("line: {}", line.toStdString());
+           if (line == QLatin1String("[GNUPG:] GET_BOOL gen_revoke.okay")) {
+             proc->write("y\n");
+           } else if (line == QLatin1String("[GNUPG:] GET_LINE "
+                                            "ask_revocation_reason.code")) {
+             proc->write("0\n");
+           } else if (line == QLatin1String("[GNUPG:] GET_LINE "
+                                            "ask_revocation_reason.text")) {
+             proc->write("\n");
+           } else if (line ==
+                      QLatin1String(
+                          "[GNUPG:] GET_BOOL openfile.overwrite.okay")) {
+             // We asked before
+             proc->write("y\n");
+           } else if (line == QLatin1String("[GNUPG:] GET_BOOL "
+                                            "ask_revocation_reason.okay")) {
+             proc->write("y\n");
+           }
+         }
+       }});
 }
 
 /**