From 95997d27106daf91336847f50efaaa32279b7fc7 Mon Sep 17 00:00:00 2001 From: saturneric Date: Mon, 16 Oct 2023 17:54:05 +0800 Subject: fix: check and update copyright at files --- src/core/function/gpg/GpgCommandExecutor.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 86c47c60..dcb188ec 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -1,5 +1,5 @@ /** - * Copyright (C) 2021 Saturneric + * Copyright (C) 2021 Saturneric * * This file is part of GpgFrontend. * @@ -20,7 +20,7 @@ * the gpg4usb project, which is under GPL-3.0-or-later. * * All the source code of GpgFrontend was modified and released by - * Saturneric starting on May 12, 2021. + * Saturneric starting on May 12, 2021. * * SPDX-License-Identifier: GPL-3.0-or-later * -- cgit v1.2.3 From 5175b3ae6687839afa2cdfe01f2fd70d714024ed Mon Sep 17 00:00:00 2001 From: saturneric Date: Tue, 17 Oct 2023 04:19:26 +0800 Subject: refactor: use c++17 features and piml tech to rewrite DataObject and Task --- src/core/function/gpg/GpgCommandExecutor.cpp | 106 ++++++++++++--------------- 1 file changed, 47 insertions(+), 59 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index dcb188ec..7d5ecc24 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -27,48 +27,56 @@ */ #include "GpgCommandExecutor.h" +#include +#include + #include "GpgFunctionObject.h" #include "core/thread/TaskRunnerGetter.h" +#include "thread/DataObject.h" GpgFrontend::GpgCommandExecutor::GpgCommandExecutor(int channel) : SingletonFunctionObject(channel) {} void GpgFrontend::GpgCommandExecutor::Execute( std::string cmd, std::vector arguments, - std::function callback, - std::function interact_func) { + GpgCommandExecutorCallback callback, + GpgCommandExecutorInteractor interact_func) { SPDLOG_DEBUG("called cmd {} arguments size: {}", cmd, arguments.size()); Thread::Task::TaskCallback result_callback = - [](int rtn, Thread::Task::DataObjectPtr data_object) { + [](int rtn, Thread::DataObjectPtr data_object) { SPDLOG_DEBUG("data object use count: {}", data_object.use_count()); - if (data_object->GetObjectSize() != 4) + if (!data_object->Check()) throw std::runtime_error("invalid data object size"); - auto exit_code = data_object->PopObject(); - auto process_stdout = data_object->PopObject(); - auto process_stderr = data_object->PopObject(); - auto callback = data_object->PopObject< - std::function>(); + auto exit_code = Thread::ExtractParams(data_object, 0); + auto process_stdout = + Thread::ExtractParams(data_object, 1); + auto process_stderr = + Thread::ExtractParams(data_object, 2); + auto callback = + Thread::ExtractParams(data_object, 3); // call callback callback(exit_code, process_stdout, process_stderr); }; Thread::Task::TaskRunnable runner = - [](GpgFrontend::Thread::Task::DataObjectPtr data_object) -> int { + [](Thread::DataObjectPtr data_object) -> int { SPDLOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); - if (data_object->GetObjectSize() != 4) + if (!data_object + ->Check()) throw std::runtime_error("invalid data object size"); // get arguments - auto cmd = data_object->PopObject(); + auto cmd = Thread::ExtractParams(data_object, 0); SPDLOG_DEBUG("get cmd: {}", cmd); - auto arguments = data_object->PopObject>(); + auto arguments = + Thread::ExtractParams>(data_object, 1); auto interact_func = - data_object->PopObject>(); + Thread::ExtractParams(data_object, 2); auto *cmd_process = new QProcess(); cmd_process->setProcessChannelMode(QProcess::MergedChannels); @@ -120,27 +128,13 @@ void GpgFrontend::GpgCommandExecutor::Execute( cmd_process->close(); cmd_process->deleteLater(); - // transfer result - SPDLOG_DEBUG("runner append object"); - data_object->AppendObject(std::move(process_stderr)); - data_object->AppendObject(std::move(process_stdout)); - data_object->AppendObject(std::move(exit_code)); - SPDLOG_DEBUG("runner append object done"); - + data_object->Swap({exit_code, process_stdout, process_stderr}); return 0; }; - // data transfer into task - auto data_object = std::make_shared(); - SPDLOG_DEBUG("executor append object"); - data_object->AppendObject(std::move(callback)); - data_object->AppendObject(std::move(interact_func)); - data_object->AppendObject(std::move(arguments)); - data_object->AppendObject(std::move(std::string{cmd})); - SPDLOG_DEBUG("executor append object done"); - auto *process_task = new GpgFrontend::Thread::Task( - std::move(runner), fmt::format("Execute/{}", cmd), data_object, + std::move(runner), fmt::format("Execute/{}", cmd), + Thread::TransferParams(cmd, arguments, interact_func, callback), std::move(result_callback)); QEventLoop looper; @@ -158,40 +152,43 @@ void GpgFrontend::GpgCommandExecutor::Execute( void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently( std::string cmd, std::vector arguments, - std::function callback, - std::function interact_func) { + GpgCommandExecutorCallback callback, + GpgCommandExecutorInteractor interact_func) { SPDLOG_DEBUG("called cmd {} arguments size: {}", cmd, arguments.size()); Thread::Task::TaskCallback result_callback = - [](int rtn, Thread::Task::DataObjectPtr data_object) { - if (data_object->GetObjectSize() != 4) + [](int rtn, Thread::DataObjectPtr data_object) { + if (!data_object->Check()) throw std::runtime_error("invalid data object size"); - auto exit_code = data_object->PopObject(); - auto process_stdout = data_object->PopObject(); - auto process_stderr = data_object->PopObject(); - auto callback = data_object->PopObject< - std::function>(); + auto exit_code = Thread::ExtractParams(data_object, 0); + auto process_stdout = + Thread::ExtractParams(data_object, 1); + auto process_stderr = + Thread::ExtractParams(data_object, 2); + auto callback = + Thread::ExtractParams(data_object, 3); // call callback callback(exit_code, process_stdout, process_stderr); }; Thread::Task::TaskRunnable runner = - [](GpgFrontend::Thread::Task::DataObjectPtr data_object) -> int { + [](GpgFrontend::Thread::DataObjectPtr data_object) -> int { SPDLOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); - if (data_object->GetObjectSize() != 4) + if (!data_object + ->Check()) throw std::runtime_error("invalid data object size"); - SPDLOG_DEBUG("runner pop object"); // get arguments - auto cmd = data_object->PopObject(); - auto arguments = data_object->PopObject>(); + auto cmd = Thread::ExtractParams(data_object, 0); + auto arguments = + Thread::ExtractParams>(data_object, 1); auto interact_func = - data_object->PopObject>(); - SPDLOG_DEBUG("runner pop object done"); + Thread::ExtractParams>(data_object, 2); auto *cmd_process = new QProcess(); cmd_process->setProcessChannelMode(QProcess::MergedChannels); @@ -244,22 +241,13 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently( cmd_process->close(); cmd_process->deleteLater(); - // transfer result - SPDLOG_DEBUG("runner append object"); - data_object->AppendObject(std::move(process_stderr)); - data_object->AppendObject(std::move(process_stdout)); - data_object->AppendObject(std::move(exit_code)); - SPDLOG_DEBUG("runner append object done"); - + data_object->Swap({exit_code, process_stdout, process_stderr}); return 0; }; // data transfer into task - auto data_object = std::make_shared(); - data_object->AppendObject(std::move(callback)); - data_object->AppendObject(std::move(interact_func)); - data_object->AppendObject(std::move(arguments)); - data_object->AppendObject(std::move(std::string{cmd})); + auto data_object = + Thread::TransferParams(cmd, arguments, interact_func, callback); auto *process_task = new GpgFrontend::Thread::Task( std::move(runner), fmt::format("ExecuteConcurrently/{}", cmd), -- cgit v1.2.3 From 55e8e3d79096c8fe3e3263de5bb1fa6b5a268490 Mon Sep 17 00:00:00 2001 From: saturneric Date: Wed, 18 Oct 2023 02:03:38 +0800 Subject: fix: solve params mismatch issues --- src/core/function/gpg/GpgCommandExecutor.cpp | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 7d5ecc24..8c04f41a 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -45,8 +45,9 @@ void GpgFrontend::GpgCommandExecutor::Execute( Thread::Task::TaskCallback result_callback = [](int rtn, Thread::DataObjectPtr data_object) { - SPDLOG_DEBUG("data object use count: {}", data_object.use_count()); - if (!data_object->Check()) + SPDLOG_DEBUG("data object use count: {}", data_object->GetObjectSize()); + if (!data_object->Check()) throw std::runtime_error("invalid data object size"); auto exit_code = Thread::ExtractParams(data_object, 0); @@ -66,8 +67,9 @@ void GpgFrontend::GpgCommandExecutor::Execute( SPDLOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); - if (!data_object - ->Check()) + if (!data_object->Check, + GpgCommandExecutorInteractor, + GpgCommandExecutorCallback>()) throw std::runtime_error("invalid data object size"); // get arguments @@ -77,6 +79,8 @@ void GpgFrontend::GpgCommandExecutor::Execute( Thread::ExtractParams>(data_object, 1); auto interact_func = Thread::ExtractParams(data_object, 2); + auto callback = + Thread::ExtractParams(data_object, 3); auto *cmd_process = new QProcess(); cmd_process->setProcessChannelMode(QProcess::MergedChannels); @@ -128,7 +132,7 @@ void GpgFrontend::GpgCommandExecutor::Execute( cmd_process->close(); cmd_process->deleteLater(); - data_object->Swap({exit_code, process_stdout, process_stderr}); + data_object->Swap({exit_code, process_stdout, process_stderr, callback}); return 0; }; @@ -179,8 +183,9 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently( SPDLOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); - if (!data_object - ->Check()) + if (!data_object->Check, + GpgCommandExecutorInteractor, + GpgCommandExecutorCallback>()) throw std::runtime_error("invalid data object size"); // get arguments @@ -189,6 +194,8 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently( Thread::ExtractParams>(data_object, 1); auto interact_func = Thread::ExtractParams>(data_object, 2); + auto callback = + Thread::ExtractParams(data_object, 3); auto *cmd_process = new QProcess(); cmd_process->setProcessChannelMode(QProcess::MergedChannels); @@ -241,7 +248,7 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently( cmd_process->close(); cmd_process->deleteLater(); - data_object->Swap({exit_code, process_stdout, process_stderr}); + data_object->Swap({exit_code, process_stdout, process_stderr, callback}); return 0; }; -- cgit v1.2.3 From 70196cf01757824a578e4d9c49a210bf136de266 Mon Sep 17 00:00:00 2001 From: saturneric Date: Wed, 18 Oct 2023 22:45:33 +0800 Subject: feat: using pool for concurrent executions, not stable yet --- src/core/function/gpg/GpgCommandExecutor.cpp | 1 + 1 file changed, 1 insertion(+) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 8c04f41a..2fee2be6 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -259,6 +259,7 @@ void GpgFrontend::GpgCommandExecutor::ExecuteConcurrently( 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) -- cgit v1.2.3 From 025c268f91ee1deab17891f00dc8c90c4770224f Mon Sep 17 00:00:00 2001 From: saturneric Date: Thu, 19 Oct 2023 18:51:20 +0800 Subject: fix: improve the stability of thread system --- src/core/function/gpg/GpgCommandExecutor.cpp | 198 ++++++++++----------------- 1 file changed, 72 insertions(+), 126 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') 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(channel) {} - -void GpgFrontend::GpgCommandExecutor::Execute( - std::string cmd, std::vector 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()) - throw std::runtime_error("invalid data object size"); - - auto exit_code = Thread::ExtractParams(data_object, 0); - auto process_stdout = - Thread::ExtractParams(data_object, 1); - auto process_stderr = - Thread::ExtractParams(data_object, 2); - auto callback = - Thread::ExtractParams(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, - GpgCommandExecutorInteractor, - GpgCommandExecutorCallback>()) - throw std::runtime_error("invalid data object size"); +namespace GpgFrontend { - // get arguments - auto cmd = Thread::ExtractParams(data_object, 0); - SPDLOG_DEBUG("get cmd: {}", cmd); - auto arguments = - Thread::ExtractParams>(data_object, 1); - auto interact_func = - Thread::ExtractParams(data_object, 2); - auto callback = - Thread::ExtractParams(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(&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(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 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()) 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(data_object, 0); + SPDLOG_DEBUG("get cmd: {}", cmd); auto arguments = Thread::ExtractParams>(data_object, 1); auto interact_func = - Thread::ExtractParams>(data_object, 2); + Thread::ExtractParams(data_object, 2); auto callback = Thread::ExtractParams(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 -- cgit v1.2.3 From 8fdeb3af49999f29e017b7f7a70bd36f020ba721 Mon Sep 17 00:00:00 2001 From: saturneric Date: Mon, 23 Oct 2023 18:27:25 +0800 Subject: perf: reduce header includes and improve build speed --- src/core/function/gpg/GpgCommandExecutor.cpp | 8 -------- 1 file changed, 8 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 2e453388..c367bd72 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -57,10 +57,6 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { 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); @@ -78,10 +74,6 @@ void GpgCommandExecutor::ExecuteConcurrentlySync( 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); -- cgit v1.2.3 From 5a3f422335b27c6c19a2d91f525c77435e8f2384 Mon Sep 17 00:00:00 2001 From: saturneric Date: Mon, 23 Oct 2023 21:23:37 +0800 Subject: fix: solve some issues on log system --- src/core/function/gpg/GpgCommandExecutor.cpp | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index c367bd72..ba2b7e02 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -27,12 +27,11 @@ */ #include "GpgCommandExecutor.h" -#include -#include +#include #include "GpgFunctionObject.h" +#include "core/thread/DataObject.h" #include "core/thread/TaskRunnerGetter.h" -#include "thread/DataObject.h" namespace GpgFrontend { @@ -196,8 +195,15 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { return 0; }; + const std::string joined_argument = std::accumulate( + std::begin(arguments), std::end(arguments), std::string(), + [](const std::string &a, const std::string &b) -> std::string { + return a + (a.length() > 0 ? " " : "") + b; + }); + return new Thread::Task( - std::move(runner), fmt::format("Execute/{}", cmd), + std::move(runner), + (boost::format("Execute(%1%){%2%}") % cmd % joined_argument).str(), Thread::TransferParams(cmd, arguments, interact_function, callback), std::move(result_callback)); } -- cgit v1.2.3 From b7ceed0b87752077fe19fefe9b0df8ec27ce0531 Mon Sep 17 00:00:00 2001 From: saturneric Date: Wed, 25 Oct 2023 22:28:25 +0800 Subject: feat: moving gnupg info gathering logic to a new module --- src/core/function/gpg/GpgCommandExecutor.cpp | 43 ++++++++++++++++++---------- 1 file changed, 28 insertions(+), 15 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index ba2b7e02..582f8afa 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -99,12 +99,19 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { auto &interact_function = context.interact_func; auto &callback = context.callback; + const std::string joined_argument = std::accumulate( + std::begin(arguments), std::end(arguments), std::string(), + [](const std::string &a, const std::string &b) -> std::string { + return a + (a.length() > 0 ? " " : "") + b; + }); + 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()); + SPDLOG_DEBUG("data object args count: {}", + data_object->GetObjectSize()); if (!data_object->Check()) throw std::runtime_error("invalid data object size"); @@ -117,12 +124,13 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { auto callback = Thread::ExtractParams(data_object, 3); + SPDLOG_DEBUG("data object args got, exit_code: {}", exit_code); // call callback callback(exit_code, process_stdout, process_stderr); }; Thread::Task::TaskRunnable runner = - [](Thread::DataObjectPtr data_object) -> int { + [joined_argument](Thread::DataObjectPtr data_object) -> int { SPDLOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); @@ -133,7 +141,6 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { // get arguments auto cmd = Thread::ExtractParams(data_object, 0); - SPDLOG_DEBUG("get cmd: {}", cmd); auto arguments = Thread::ExtractParams>(data_object, 1); auto interact_func = @@ -142,6 +149,7 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { Thread::ExtractParams(data_object, 3); auto *cmd_process = new QProcess(); + cmd_process->moveToThread(QThread::currentThread()); cmd_process->setProcessChannelMode(QProcess::MergedChannels); QObject::connect(cmd_process, &QProcess::started, @@ -157,16 +165,27 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { QObject::connect( cmd_process, qOverload(&QProcess::finished), [=](int, QProcess::ExitStatus status) { + int exit_code = cmd_process->exitCode(); if (status == QProcess::NormalExit) SPDLOG_DEBUG( - "proceess finished, succeed in executing command: {}, exit " - "status: {}", - cmd, status); + "proceess finished, succeed in executing command: {} {}, exit " + "code: {}", + cmd, joined_argument, exit_code); else SPDLOG_ERROR( - "proceess finished, error in executing command: {}, exit " - "status: {}", - cmd, status); + "proceess finished, error in executing command: {} {}, exit " + "code: {}", + cmd, joined_argument, exit_code); + std::string process_stdout = + cmd_process->readAllStandardOutput().toStdString(), + process_stderr = + cmd_process->readAllStandardError().toStdString(); + + cmd_process->close(); + cmd_process->deleteLater(); + + data_object->Swap( + {exit_code, process_stdout, process_stderr, callback}); }); cmd_process->setProgram(QString::fromStdString(cmd)); @@ -195,12 +214,6 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { return 0; }; - const std::string joined_argument = std::accumulate( - std::begin(arguments), std::end(arguments), std::string(), - [](const std::string &a, const std::string &b) -> std::string { - return a + (a.length() > 0 ? " " : "") + b; - }); - return new Thread::Task( std::move(runner), (boost::format("Execute(%1%){%2%}") % cmd % joined_argument).str(), -- cgit v1.2.3 From ffc635e82ed2d85e41a86a5c9a12c6c98180d4b7 Mon Sep 17 00:00:00 2001 From: saturneric Date: Thu, 26 Oct 2023 20:55:53 +0800 Subject: fix: improve the commu between gig module and core --- src/core/function/gpg/GpgCommandExecutor.cpp | 110 ++++++++++++++------------- 1 file changed, 59 insertions(+), 51 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 582f8afa..3fd56d35 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -28,18 +28,26 @@ #include "GpgCommandExecutor.h" #include +#include #include "GpgFunctionObject.h" #include "core/thread/DataObject.h" #include "core/thread/TaskRunnerGetter.h" +#include "spdlog/spdlog.h" namespace GpgFrontend { +GpgCommandExecutor::ExecuteContext::ExecuteContext( + std::string cmd, std::vector arguments, + GpgCommandExecutorCallback callback, GpgCommandExecutorInteractor int_func) + : cmd(cmd), arguments(arguments), cb_func(callback), int_func(int_func) {} + GpgCommandExecutor::GpgCommandExecutor(int channel) : SingletonFunctionObject(channel) {} void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { - Thread::Task *task = build_task(context); + Thread::Task *task = build_task_from_exec_ctx(context); + QEventLoop looper; QObject::connect(task, &Thread::Task::SignalTaskEnd, &looper, &QEventLoop::quit); @@ -58,7 +66,7 @@ void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { auto &cmd = context.cmd; SPDLOG_INFO("gpg concurrently called cmd {}", cmd); - Thread::Task *task = build_task(context); + Thread::Task *task = build_task_from_exec_ctx(context); GpgFrontend::Thread::TaskRunnerGetter::GetInstance() .GetTaskRunner( Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) @@ -75,7 +83,7 @@ void GpgCommandExecutor::ExecuteConcurrentlySync( auto &cmd = context.cmd; SPDLOG_INFO("gpg concurrently called cmd {}", cmd); - Thread::Task *task = build_task(context); + Thread::Task *task = build_task_from_exec_ctx(context); QObject::connect(task, &Thread::Task::SignalTaskEnd, [&]() { --remainingTasks; @@ -93,11 +101,12 @@ void GpgCommandExecutor::ExecuteConcurrentlySync( looper.exec(); } -Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { +Thread::Task *GpgCommandExecutor::build_task_from_exec_ctx( + const ExecuteContext &context) { auto &cmd = context.cmd; auto &arguments = context.arguments; - auto &interact_function = context.interact_func; - auto &callback = context.callback; + auto &interact_function = context.int_func; + auto &cmd_executor_callback = context.cb_func; const std::string joined_argument = std::accumulate( std::begin(arguments), std::end(arguments), std::string(), @@ -109,9 +118,10 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { arguments.size()); Thread::Task::TaskCallback result_callback = - [](int rtn, Thread::DataObjectPtr data_object) { - SPDLOG_DEBUG("data object args count: {}", - data_object->GetObjectSize()); + [cmd, joined_argument](int rtn, Thread::DataObjectPtr data_object) { + SPDLOG_DEBUG( + "data object args count of cmd executor result callback: {}", + data_object->GetObjectSize()); if (!data_object->Check()) throw std::runtime_error("invalid data object size"); @@ -124,8 +134,11 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { auto callback = Thread::ExtractParams(data_object, 3); - SPDLOG_DEBUG("data object args got, exit_code: {}", exit_code); // call callback + SPDLOG_DEBUG( + "calling custom callback from caller of cmd {} {}, " + "exit_code: {}", + cmd, joined_argument, exit_code); callback(exit_code, process_stdout, process_stderr); }; @@ -151,52 +164,33 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { auto *cmd_process = new QProcess(); cmd_process->moveToThread(QThread::currentThread()); cmd_process->setProcessChannelMode(QProcess::MergedChannels); + cmd_process->setProgram(QString::fromStdString(cmd)); + QStringList q_arguments; + for (const auto &argument : arguments) + q_arguments.append(QString::fromStdString(argument)); + cmd_process->setArguments(q_arguments); - QObject::connect(cmd_process, &QProcess::started, - []() -> void { SPDLOG_DEBUG("process started"); }); + QObject::connect( + cmd_process, &QProcess::started, [cmd, joined_argument]() -> void { + SPDLOG_DEBUG( + "\n== Process Execute Started ==\nCommand: {}\nArguments: " + "{}\n========================", + cmd, joined_argument); + }); 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(&QProcess::finished), - [=](int, QProcess::ExitStatus status) { - int exit_code = cmd_process->exitCode(); - if (status == QProcess::NormalExit) - SPDLOG_DEBUG( - "proceess finished, succeed in executing command: {} {}, exit " - "code: {}", - cmd, joined_argument, exit_code); - else - SPDLOG_ERROR( - "proceess finished, error in executing command: {} {}, exit " - "code: {}", - cmd, joined_argument, exit_code); - std::string process_stdout = - cmd_process->readAllStandardOutput().toStdString(), - process_stderr = - cmd_process->readAllStandardError().toStdString(); - - cmd_process->close(); - cmd_process->deleteLater(); - - data_object->Swap( - {exit_code, process_stdout, process_stderr, callback}); + cmd_process, &QProcess::errorOccurred, + [=](QProcess::ProcessError error) { + SPDLOG_ERROR("caught error while executing command: {} {}, error: {}", + cmd, joined_argument, error); }); - cmd_process->setProgram(QString::fromStdString(cmd)); - - QStringList q_arguments; - for (const auto &argument : arguments) - q_arguments.append(QString::fromStdString(argument)); - cmd_process->setArguments(q_arguments); - - SPDLOG_DEBUG("process execute ready, cmd: {} {}", cmd, - q_arguments.join(" ").toStdString()); + SPDLOG_DEBUG( + "\n== Process Execute Ready ==\nCommand: {}\nArguments: " + "{}\n========================", + cmd, joined_argument); cmd_process->start(); cmd_process->waitForFinished(); @@ -207,6 +201,18 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { cmd_process->readAllStandardError().toStdString(); int exit_code = cmd_process->exitCode(); + SPDLOG_DEBUG( + "\n==== Process Execution Summary ====\n" + "Command: {}\n" + "Arguments: {}\n" + "Exit Code: {}\n" + "---- Standard Output ----\n" + "{}\n" + "---- Standard Error ----\n" + "{}\n" + "===============================", + cmd, joined_argument, exit_code, process_stdout, process_stderr); + cmd_process->close(); cmd_process->deleteLater(); @@ -216,8 +222,10 @@ Thread::Task *GpgCommandExecutor::build_task(const ExecuteContext &context) { return new Thread::Task( std::move(runner), - (boost::format("Execute(%1%){%2%}") % cmd % joined_argument).str(), - Thread::TransferParams(cmd, arguments, interact_function, callback), + (boost::format("GpgCommamdExecutor(%1%){%2%}") % cmd % joined_argument) + .str(), + Thread::TransferParams(cmd, arguments, interact_function, + cmd_executor_callback), std::move(result_callback)); } -- cgit v1.2.3 From 41c12e92031284e357bab04fe6e08b45c6dd3ba8 Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 27 Oct 2023 21:21:03 +0800 Subject: feat: improve thread system and gathering gnupg options info to rt --- src/core/function/gpg/GpgCommandExecutor.cpp | 59 ++++++++++++++++++++-------- 1 file changed, 43 insertions(+), 16 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 3fd56d35..fb1d647d 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -33,14 +33,21 @@ #include "GpgFunctionObject.h" #include "core/thread/DataObject.h" #include "core/thread/TaskRunnerGetter.h" +#include "module/Module.h" #include "spdlog/spdlog.h" +#include "thread/Task.h" namespace GpgFrontend { GpgCommandExecutor::ExecuteContext::ExecuteContext( std::string cmd, std::vector arguments, - GpgCommandExecutorCallback callback, GpgCommandExecutorInteractor int_func) - : cmd(cmd), arguments(arguments), cb_func(callback), int_func(int_func) {} + GpgCommandExecutorCallback callback, Module::TaskRunnerPtr task_runner, + GpgCommandExecutorInteractor int_func) + : cmd(cmd), + arguments(arguments), + cb_func(callback), + int_func(int_func), + task_runner(task_runner) {} GpgCommandExecutor::GpgCommandExecutor(int channel) : SingletonFunctionObject(channel) {} @@ -52,13 +59,26 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { QObject::connect(task, &Thread::Task::SignalTaskEnd, &looper, &QEventLoop::quit); - GpgFrontend::Thread::TaskRunnerGetter::GetInstance() - .GetTaskRunner(Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) - ->PostTask(task); + Thread::TaskRunnerPtr target_task_runner = nullptr; - // block until task finished - // this is to keep reference vaild until task finished - looper.exec(); + if (context.task_runner != nullptr) { + target_task_runner = context.task_runner; + } else { + target_task_runner = + GpgFrontend::Thread::TaskRunnerGetter::GetInstance().GetTaskRunner( + Thread::TaskRunnerGetter::kTaskRunnerType_External_Process); + } + + target_task_runner->PostTask(task); + + // to arvoid dead lock issue we need to check if current thread is the same as + // target thread. if it is, we can't call exec() because it will block the + // current thread. + if (QThread::currentThread() != target_task_runner->GetThread()) { + // block until task finished + // this is to keep reference vaild until task finished + looper.exec(); + } } void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { @@ -67,10 +87,14 @@ void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { SPDLOG_INFO("gpg concurrently called cmd {}", cmd); Thread::Task *task = build_task_from_exec_ctx(context); - GpgFrontend::Thread::TaskRunnerGetter::GetInstance() - .GetTaskRunner( - Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) - ->PostTask(task); + + if (context.task_runner != nullptr) + context.task_runner->PostTask(task); + else + GpgFrontend::Thread::TaskRunnerGetter::GetInstance() + .GetTaskRunner( + Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) + ->PostTask(task); } } @@ -92,10 +116,13 @@ void GpgCommandExecutor::ExecuteConcurrentlySync( } }); - GpgFrontend::Thread::TaskRunnerGetter::GetInstance() - .GetTaskRunner( - Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) - ->PostConcurrentTask(task); + if (context.task_runner != nullptr) + context.task_runner->PostTask(task); + else + GpgFrontend::Thread::TaskRunnerGetter::GetInstance() + .GetTaskRunner( + Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) + ->PostTask(task); } looper.exec(); -- cgit v1.2.3 From fd46d4667611c0db9cea3f06205727399b6fb5fd Mon Sep 17 00:00:00 2001 From: saturneric Date: Sun, 29 Oct 2023 02:46:15 +0800 Subject: refactor: start to tidy up code using clang-tidy --- src/core/function/gpg/GpgCommandExecutor.cpp | 246 ++++++++++++++------------- 1 file changed, 124 insertions(+), 122 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index fb1d647d..5cf57b27 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -28,112 +28,22 @@ #include "GpgCommandExecutor.h" #include -#include +#include #include "GpgFunctionObject.h" -#include "core/thread/DataObject.h" +#include "core/model/DataObject.h" +#include "core/module/Module.h" +#include "core/thread/Task.h" #include "core/thread/TaskRunnerGetter.h" -#include "module/Module.h" -#include "spdlog/spdlog.h" -#include "thread/Task.h" namespace GpgFrontend { -GpgCommandExecutor::ExecuteContext::ExecuteContext( - std::string cmd, std::vector arguments, - GpgCommandExecutorCallback callback, Module::TaskRunnerPtr task_runner, - GpgCommandExecutorInteractor int_func) - : cmd(cmd), - arguments(arguments), - cb_func(callback), - int_func(int_func), - task_runner(task_runner) {} - -GpgCommandExecutor::GpgCommandExecutor(int channel) - : SingletonFunctionObject(channel) {} - -void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { - Thread::Task *task = build_task_from_exec_ctx(context); - - QEventLoop looper; - QObject::connect(task, &Thread::Task::SignalTaskEnd, &looper, - &QEventLoop::quit); - - Thread::TaskRunnerPtr target_task_runner = nullptr; - - if (context.task_runner != nullptr) { - target_task_runner = context.task_runner; - } else { - target_task_runner = - GpgFrontend::Thread::TaskRunnerGetter::GetInstance().GetTaskRunner( - Thread::TaskRunnerGetter::kTaskRunnerType_External_Process); - } - - target_task_runner->PostTask(task); - - // to arvoid dead lock issue we need to check if current thread is the same as - // target thread. if it is, we can't call exec() because it will block the - // current thread. - if (QThread::currentThread() != target_task_runner->GetThread()) { - // block until task finished - // this is to keep reference vaild until task finished - looper.exec(); - } -} - -void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { - for (auto &context : contexts) { - auto &cmd = context.cmd; - SPDLOG_INFO("gpg concurrently called cmd {}", cmd); - - Thread::Task *task = build_task_from_exec_ctx(context); - - if (context.task_runner != nullptr) - context.task_runner->PostTask(task); - else - GpgFrontend::Thread::TaskRunnerGetter::GetInstance() - .GetTaskRunner( - Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) - ->PostTask(task); - } -} - -void GpgCommandExecutor::ExecuteConcurrentlySync( - const ExecuteContexts contexts) { - QEventLoop looper; - int remainingTasks = contexts.size(); - - for (auto &context : contexts) { - auto &cmd = context.cmd; - SPDLOG_INFO("gpg concurrently called cmd {}", cmd); - - Thread::Task *task = build_task_from_exec_ctx(context); - - QObject::connect(task, &Thread::Task::SignalTaskEnd, [&]() { - --remainingTasks; - if (remainingTasks <= 0) { - looper.quit(); - } - }); - - if (context.task_runner != nullptr) - context.task_runner->PostTask(task); - else - GpgFrontend::Thread::TaskRunnerGetter::GetInstance() - .GetTaskRunner( - Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) - ->PostTask(task); - } - - looper.exec(); -} - -Thread::Task *GpgCommandExecutor::build_task_from_exec_ctx( - const ExecuteContext &context) { - auto &cmd = context.cmd; - auto &arguments = context.arguments; - auto &interact_function = context.int_func; - auto &cmd_executor_callback = context.cb_func; +auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) + -> Thread::Task * { + const auto &cmd = context.cmd; + const auto &arguments = context.arguments; + const auto &interact_function = context.int_func; + const auto &cmd_executor_callback = context.cb_func; const std::string joined_argument = std::accumulate( std::begin(arguments), std::end(arguments), std::string(), @@ -145,21 +55,20 @@ Thread::Task *GpgCommandExecutor::build_task_from_exec_ctx( arguments.size()); Thread::Task::TaskCallback result_callback = - [cmd, joined_argument](int rtn, Thread::DataObjectPtr data_object) { + [cmd, joined_argument](int /*rtn*/, const DataObjectPtr &data_object) { SPDLOG_DEBUG( "data object args count of cmd executor result callback: {}", data_object->GetObjectSize()); if (!data_object->Check()) + GpgCommandExecutorCallback>()) { throw std::runtime_error("invalid data object size"); + } - auto exit_code = Thread::ExtractParams(data_object, 0); - auto process_stdout = - Thread::ExtractParams(data_object, 1); - auto process_stderr = - Thread::ExtractParams(data_object, 2); + auto exit_code = ExtractParams(data_object, 0); + auto process_stdout = ExtractParams(data_object, 1); + auto process_stderr = ExtractParams(data_object, 2); auto callback = - Thread::ExtractParams(data_object, 3); + ExtractParams(data_object, 3); // call callback SPDLOG_DEBUG( @@ -170,31 +79,38 @@ Thread::Task *GpgCommandExecutor::build_task_from_exec_ctx( }; Thread::Task::TaskRunnable runner = - [joined_argument](Thread::DataObjectPtr data_object) -> int { + [joined_argument](const DataObjectPtr &data_object) -> int { SPDLOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); if (!data_object->Check, GpgCommandExecutorInteractor, - GpgCommandExecutorCallback>()) + GpgCommandExecutorCallback>()) { throw std::runtime_error("invalid data object size"); + } // get arguments - auto cmd = Thread::ExtractParams(data_object, 0); - auto arguments = - Thread::ExtractParams>(data_object, 1); + auto cmd = ExtractParams(data_object, 0); + auto arguments = ExtractParams>(data_object, 1); auto interact_func = - Thread::ExtractParams(data_object, 2); - auto callback = - Thread::ExtractParams(data_object, 3); + ExtractParams(data_object, 2); + auto callback = ExtractParams(data_object, 3); + // create process auto *cmd_process = new QProcess(); + // move to current thread + // cmd_process->moveToThread(QThread::currentThread()); + // set process channel mode + // this is to make sure we can get all output from stdout and stderr cmd_process->setProcessChannelMode(QProcess::MergedChannels); cmd_process->setProgram(QString::fromStdString(cmd)); + + // set arguments QStringList q_arguments; - for (const auto &argument : arguments) + for (const auto &argument : arguments) { q_arguments.append(QString::fromStdString(argument)); + } cmd_process->setArguments(q_arguments); QObject::connect( @@ -223,9 +139,9 @@ Thread::Task *GpgCommandExecutor::build_task_from_exec_ctx( cmd_process->waitForFinished(); std::string process_stdout = - cmd_process->readAllStandardOutput().toStdString(), - process_stderr = - cmd_process->readAllStandardError().toStdString(); + cmd_process->readAllStandardOutput().toStdString(); + std::string process_stderr = + cmd_process->readAllStandardError().toStdString(); int exit_code = cmd_process->exitCode(); SPDLOG_DEBUG( @@ -251,9 +167,95 @@ Thread::Task *GpgCommandExecutor::build_task_from_exec_ctx( std::move(runner), (boost::format("GpgCommamdExecutor(%1%){%2%}") % cmd % joined_argument) .str(), - Thread::TransferParams(cmd, arguments, interact_function, - cmd_executor_callback), + TransferParams(cmd, arguments, interact_function, cmd_executor_callback), std::move(result_callback)); } +GpgCommandExecutor::ExecuteContext::ExecuteContext( + std::string cmd, std::vector arguments, + GpgCommandExecutorCallback callback, Module::TaskRunnerPtr task_runner, + GpgCommandExecutorInteractor int_func) + : cmd(std::move(cmd)), + arguments(std::move(arguments)), + cb_func(std::move(callback)), + int_func(std::move(int_func)), + task_runner(std::move(task_runner)) {} + +void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { + Thread::Task *task = BuildTaskFromExecCtx(context); + + QEventLoop looper; + QObject::connect(task, &Thread::Task::SignalTaskEnd, &looper, + &QEventLoop::quit); + + Thread::TaskRunnerPtr target_task_runner = nullptr; + + if (context.task_runner != nullptr) { + target_task_runner = context.task_runner; + } else { + target_task_runner = + GpgFrontend::Thread::TaskRunnerGetter::GetInstance().GetTaskRunner( + Thread::TaskRunnerGetter::kTaskRunnerType_External_Process); + } + + target_task_runner->PostTask(task); + + // to arvoid dead lock issue we need to check if current thread is the same as + // target thread. if it is, we can't call exec() because it will block the + // current thread. + if (QThread::currentThread() != target_task_runner->GetThread()) { + // block until task finished + // this is to keep reference vaild until task finished + looper.exec(); + } +} + +void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { + for (auto &context : contexts) { + const auto &cmd = context.cmd; + SPDLOG_INFO("gpg concurrently called cmd {}", cmd); + + Thread::Task *task = BuildTaskFromExecCtx(context); + + if (context.task_runner != nullptr) { + context.task_runner->PostTask(task); + } else { + GpgFrontend::Thread::TaskRunnerGetter::GetInstance() + .GetTaskRunner( + Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) + ->PostTask(task); + } + } +} + +void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { + QEventLoop looper; + auto remaining_tasks = contexts.size(); + + for (auto &context : contexts) { + const auto &cmd = context.cmd; + SPDLOG_INFO("gpg concurrently called cmd {}", cmd); + + Thread::Task *task = BuildTaskFromExecCtx(context); + + QObject::connect(task, &Thread::Task::SignalTaskEnd, [&]() { + --remaining_tasks; + if (remaining_tasks <= 0) { + looper.quit(); + } + }); + + if (context.task_runner != nullptr) { + context.task_runner->PostTask(task); + } else { + GpgFrontend::Thread::TaskRunnerGetter::GetInstance() + .GetTaskRunner( + Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) + ->PostTask(task); + } + } + + looper.exec(); +} + } // namespace GpgFrontend \ No newline at end of file -- cgit v1.2.3 From 0251f35c93e3f0e0a6853a50fb5bd82c1b9e4187 Mon Sep 17 00:00:00 2001 From: saturneric Date: Mon, 6 Nov 2023 17:17:47 +0800 Subject: refactor: clean up core's codes --- src/core/function/gpg/GpgCommandExecutor.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 5cf57b27..d05cc626 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -30,7 +30,7 @@ #include #include -#include "GpgFunctionObject.h" +#include "core/function/basic/GpgFunctionObject.h" #include "core/model/DataObject.h" #include "core/module/Module.h" #include "core/thread/Task.h" -- cgit v1.2.3 From 054e6e28cca2517dda2319ef683314b3318c39a6 Mon Sep 17 00:00:00 2001 From: saturneric Date: Sun, 3 Dec 2023 12:25:21 -0800 Subject: feat: standarized and speed up app env loading process --- src/core/function/gpg/GpgCommandExecutor.cpp | 31 ++++++++++++++++++++++------ 1 file changed, 25 insertions(+), 6 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index d05cc626..1717c6e0 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -35,6 +35,7 @@ #include "core/module/Module.h" #include "core/thread/Task.h" #include "core/thread/TaskRunnerGetter.h" +#include "spdlog/spdlog.h" namespace GpgFrontend { @@ -231,6 +232,9 @@ void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { QEventLoop looper; auto remaining_tasks = contexts.size(); + Thread::TaskRunnerPtr target_task_runner = nullptr; + + bool need_looper = true; for (auto &context : contexts) { const auto &cmd = context.cmd; @@ -240,22 +244,37 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { QObject::connect(task, &Thread::Task::SignalTaskEnd, [&]() { --remaining_tasks; + SPDLOG_DEBUG("remaining tasks: {}", remaining_tasks); if (remaining_tasks <= 0) { + SPDLOG_DEBUG("no remaining task, quit"); looper.quit(); } }); if (context.task_runner != nullptr) { - context.task_runner->PostTask(task); + target_task_runner = context.task_runner; } else { - GpgFrontend::Thread::TaskRunnerGetter::GetInstance() - .GetTaskRunner( - Thread::TaskRunnerGetter::kTaskRunnerType_External_Process) - ->PostTask(task); + target_task_runner = + GpgFrontend::Thread::TaskRunnerGetter::GetInstance().GetTaskRunner( + Thread::TaskRunnerGetter::kTaskRunnerType_External_Process); + } + + target_task_runner->PostTask(task); + + // to arvoid dead lock issue we need to check if current thread is the same + // as + // target thread. if it is, we can't call exec() because it will block the + // current thread. + if (QThread::currentThread() == target_task_runner->GetThread()) { + need_looper = false; } } - looper.exec(); + if (need_looper) { + // block until task finished + // this is to keep reference vaild until task finished + looper.exec(); + } } } // namespace GpgFrontend \ No newline at end of file -- cgit v1.2.3 From 4f29479ec7c128ab035d76e32006d8b0c7d0b9f1 Mon Sep 17 00:00:00 2001 From: saturneric Date: Sat, 23 Dec 2023 20:07:26 +0800 Subject: fix: solve all issues of test cases on macos m1 --- src/core/function/gpg/GpgCommandExecutor.cpp | 1 - 1 file changed, 1 deletion(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 1717c6e0..02d22d07 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -35,7 +35,6 @@ #include "core/module/Module.h" #include "core/thread/Task.h" #include "core/thread/TaskRunnerGetter.h" -#include "spdlog/spdlog.h" namespace GpgFrontend { -- cgit v1.2.3 From baae835db98f3b088120572a1803afdce221db00 Mon Sep 17 00:00:00 2001 From: saturneric Date: Sun, 24 Dec 2023 14:08:21 +0800 Subject: fix: test the initialization of gui application --- src/core/function/gpg/GpgCommandExecutor.cpp | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 02d22d07..6718d62a 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -197,13 +197,14 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { GpgFrontend::Thread::TaskRunnerGetter::GetInstance().GetTaskRunner( Thread::TaskRunnerGetter::kTaskRunnerType_External_Process); } - target_task_runner->PostTask(task); // to arvoid dead lock issue we need to check if current thread is the same as // target thread. if it is, we can't call exec() because it will block the // current thread. - if (QThread::currentThread() != target_task_runner->GetThread()) { + if (QThread::currentThread()->currentThreadId() != + target_task_runner->GetThread()->currentThreadId()) { + SPDLOG_TRACE("blocking until gpg command finish..."); // block until task finished // this is to keep reference vaild until task finished looper.exec(); @@ -233,7 +234,7 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { auto remaining_tasks = contexts.size(); Thread::TaskRunnerPtr target_task_runner = nullptr; - bool need_looper = true; + bool need_looper = false; for (auto &context : contexts) { const auto &cmd = context.cmd; @@ -261,15 +262,16 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { target_task_runner->PostTask(task); // to arvoid dead lock issue we need to check if current thread is the same - // as - // target thread. if it is, we can't call exec() because it will block the - // current thread. - if (QThread::currentThread() == target_task_runner->GetThread()) { - need_looper = false; + // as target thread. if it is, we can't call exec() because it will block + // the current thread. + if (QThread::currentThread()->currentThreadId() != + target_task_runner->GetThread()->currentThreadId()) { + need_looper = true; } } if (need_looper) { + SPDLOG_TRACE("blocking until concurrent gpg commands finish..."); // block until task finished // this is to keep reference vaild until task finished looper.exec(); -- cgit v1.2.3 From 3c40fa27823e70215261d3845275360f85e59623 Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 5 Jan 2024 16:11:24 +0800 Subject: fix: slove some known issues --- src/core/function/gpg/GpgCommandExecutor.cpp | 52 ++++++++++++---------------- 1 file changed, 23 insertions(+), 29 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 6718d62a..fbcb1e4d 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -54,29 +54,27 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) SPDLOG_DEBUG("building task: called cmd {} arguments size: {}", cmd, arguments.size()); - Thread::Task::TaskCallback result_callback = - [cmd, joined_argument](int /*rtn*/, const DataObjectPtr &data_object) { - SPDLOG_DEBUG( - "data object args count of cmd executor result callback: {}", - data_object->GetObjectSize()); - if (!data_object->Check()) { - throw std::runtime_error("invalid data object size"); - } - - auto exit_code = ExtractParams(data_object, 0); - auto process_stdout = ExtractParams(data_object, 1); - auto process_stderr = ExtractParams(data_object, 2); - auto callback = - ExtractParams(data_object, 3); - - // call callback - SPDLOG_DEBUG( - "calling custom callback from caller of cmd {} {}, " - "exit_code: {}", - cmd, joined_argument, exit_code); - callback(exit_code, process_stdout, process_stderr); - }; + Thread::Task::TaskCallback result_callback = [cmd, joined_argument]( + int /*rtn*/, + const DataObjectPtr + &data_object) { + SPDLOG_DEBUG("data object args count of cmd executor result callback: {}", + data_object->GetObjectSize()); + if (!data_object->Check()) { + throw std::runtime_error("invalid data object size"); + } + + auto exit_code = ExtractParams(data_object, 0); + auto process_stdout = ExtractParams(data_object, 1); + auto callback = ExtractParams(data_object, 2); + + // call callback + SPDLOG_DEBUG( + "calling custom callback from caller of cmd {} {}, " + "exit_code: {}", + cmd, joined_argument, exit_code); + callback(exit_code, process_stdout, {}); + }; Thread::Task::TaskRunnable runner = [joined_argument](const DataObjectPtr &data_object) -> int { @@ -140,8 +138,6 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) std::string process_stdout = cmd_process->readAllStandardOutput().toStdString(); - std::string process_stderr = - cmd_process->readAllStandardError().toStdString(); int exit_code = cmd_process->exitCode(); SPDLOG_DEBUG( @@ -151,15 +147,13 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) "Exit Code: {}\n" "---- Standard Output ----\n" "{}\n" - "---- Standard Error ----\n" - "{}\n" "===============================", - cmd, joined_argument, exit_code, process_stdout, process_stderr); + cmd, joined_argument, exit_code, process_stdout); cmd_process->close(); cmd_process->deleteLater(); - data_object->Swap({exit_code, process_stdout, process_stderr, callback}); + data_object->Swap({exit_code, process_stdout, callback}); return 0; }; -- cgit v1.2.3 From 644aa4397b03dbef73f8bfedc13925b51cad836b Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 5 Jan 2024 20:55:15 +0800 Subject: feat: integrate logging api to core --- src/core/function/gpg/GpgCommandExecutor.cpp | 76 ++++++++++++++-------------- 1 file changed, 39 insertions(+), 37 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index fbcb1e4d..fa4b7dbd 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -51,35 +51,36 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) return a + (a.length() > 0 ? " " : "") + b; }); - SPDLOG_DEBUG("building task: called cmd {} arguments size: {}", cmd, - arguments.size()); - - Thread::Task::TaskCallback result_callback = [cmd, joined_argument]( - int /*rtn*/, - const DataObjectPtr - &data_object) { - SPDLOG_DEBUG("data object args count of cmd executor result callback: {}", - data_object->GetObjectSize()); - if (!data_object->Check()) { - throw std::runtime_error("invalid data object size"); - } - - auto exit_code = ExtractParams(data_object, 0); - auto process_stdout = ExtractParams(data_object, 1); - auto callback = ExtractParams(data_object, 2); - - // call callback - SPDLOG_DEBUG( - "calling custom callback from caller of cmd {} {}, " - "exit_code: {}", - cmd, joined_argument, exit_code); - callback(exit_code, process_stdout, {}); - }; + GF_CORE_LOG_DEBUG("building task: called cmd {} arguments size: {}", cmd, + arguments.size()); + + Thread::Task::TaskCallback result_callback = + [cmd, joined_argument](int /*rtn*/, const DataObjectPtr &data_object) { + GF_CORE_LOG_DEBUG( + "data object args count of cmd executor result callback: {}", + data_object->GetObjectSize()); + if (!data_object + ->Check()) { + throw std::runtime_error("invalid data object size"); + } + + auto exit_code = ExtractParams(data_object, 0); + auto process_stdout = ExtractParams(data_object, 1); + auto callback = + ExtractParams(data_object, 2); + + // call callback + GF_CORE_LOG_DEBUG( + "calling custom callback from caller of cmd {} {}, " + "exit_code: {}", + cmd, joined_argument, exit_code); + callback(exit_code, process_stdout, {}); + }; Thread::Task::TaskRunnable runner = [joined_argument](const DataObjectPtr &data_object) -> int { - SPDLOG_DEBUG("process runner called, data object size: {}", - data_object->GetObjectSize()); + GF_CORE_LOG_DEBUG("process runner called, data object size: {}", + data_object->GetObjectSize()); if (!data_object->Check, GpgCommandExecutorInteractor, @@ -113,7 +114,7 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) QObject::connect( cmd_process, &QProcess::started, [cmd, joined_argument]() -> void { - SPDLOG_DEBUG( + GF_CORE_LOG_DEBUG( "\n== Process Execute Started ==\nCommand: {}\nArguments: " "{}\n========================", cmd, joined_argument); @@ -124,11 +125,12 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) QObject::connect( cmd_process, &QProcess::errorOccurred, [=](QProcess::ProcessError error) { - SPDLOG_ERROR("caught error while executing command: {} {}, error: {}", - cmd, joined_argument, error); + GF_CORE_LOG_ERROR( + "caught error while executing command: {} {}, error: {}", cmd, + joined_argument, error); }); - SPDLOG_DEBUG( + GF_CORE_LOG_DEBUG( "\n== Process Execute Ready ==\nCommand: {}\nArguments: " "{}\n========================", cmd, joined_argument); @@ -140,7 +142,7 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) cmd_process->readAllStandardOutput().toStdString(); int exit_code = cmd_process->exitCode(); - SPDLOG_DEBUG( + GF_CORE_LOG_DEBUG( "\n==== Process Execution Summary ====\n" "Command: {}\n" "Arguments: {}\n" @@ -198,7 +200,7 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { // current thread. if (QThread::currentThread()->currentThreadId() != target_task_runner->GetThread()->currentThreadId()) { - SPDLOG_TRACE("blocking until gpg command finish..."); + GF_CORE_LOG_TRACE("blocking until gpg command finish..."); // block until task finished // this is to keep reference vaild until task finished looper.exec(); @@ -208,7 +210,7 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { for (auto &context : contexts) { const auto &cmd = context.cmd; - SPDLOG_INFO("gpg concurrently called cmd {}", cmd); + GF_CORE_LOG_INFO("gpg concurrently called cmd {}", cmd); Thread::Task *task = BuildTaskFromExecCtx(context); @@ -232,15 +234,15 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { for (auto &context : contexts) { const auto &cmd = context.cmd; - SPDLOG_INFO("gpg concurrently called cmd {}", cmd); + GF_CORE_LOG_DEBUG("gpg concurrently called cmd {}", cmd); Thread::Task *task = BuildTaskFromExecCtx(context); QObject::connect(task, &Thread::Task::SignalTaskEnd, [&]() { --remaining_tasks; - SPDLOG_DEBUG("remaining tasks: {}", remaining_tasks); + GF_CORE_LOG_DEBUG("remaining tasks: {}", remaining_tasks); if (remaining_tasks <= 0) { - SPDLOG_DEBUG("no remaining task, quit"); + GF_CORE_LOG_DEBUG("no remaining task, quit"); looper.quit(); } }); @@ -265,7 +267,7 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { } if (need_looper) { - SPDLOG_TRACE("blocking until concurrent gpg commands finish..."); + GF_CORE_LOG_TRACE("blocking until concurrent gpg commands finish..."); // block until task finished // this is to keep reference vaild until task finished looper.exec(); -- cgit v1.2.3 From 57438e754cd857ef48c3960eefe2e957716acd80 Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 5 Jan 2024 21:28:59 +0800 Subject: fix: slove a multi-threads issue at task model --- src/core/function/gpg/GpgCommandExecutor.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index fa4b7dbd..fd6d6099 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -234,7 +234,7 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { for (auto &context : contexts) { const auto &cmd = context.cmd; - GF_CORE_LOG_DEBUG("gpg concurrently called cmd {}", cmd); + GF_CORE_LOG_DEBUG("gpg concurrently called cmd: {}", cmd); Thread::Task *task = BuildTaskFromExecCtx(context); -- cgit v1.2.3 From bf538056b24a68b8fd235b1c50991ee8eb46a776 Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 12 Jan 2024 14:02:37 +0800 Subject: refactor: use QString instead of std::string and improve threading system --- src/core/function/gpg/GpgCommandExecutor.cpp | 34 ++++++++++------------------ 1 file changed, 12 insertions(+), 22 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index fd6d6099..713d9aba 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -27,7 +27,6 @@ */ #include "GpgCommandExecutor.h" -#include #include #include "core/function/basic/GpgFunctionObject.h" @@ -45,11 +44,7 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) const auto &interact_function = context.int_func; const auto &cmd_executor_callback = context.cb_func; - const std::string joined_argument = std::accumulate( - std::begin(arguments), std::end(arguments), std::string(), - [](const std::string &a, const std::string &b) -> std::string { - return a + (a.length() > 0 ? " " : "") + b; - }); + const QString joined_argument = QStringList::fromVector(arguments).join(" "); GF_CORE_LOG_DEBUG("building task: called cmd {} arguments size: {}", cmd, arguments.size()); @@ -59,13 +54,12 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) GF_CORE_LOG_DEBUG( "data object args count of cmd executor result callback: {}", data_object->GetObjectSize()); - if (!data_object - ->Check()) { + if (!data_object->Check()) { throw std::runtime_error("invalid data object size"); } auto exit_code = ExtractParams(data_object, 0); - auto process_stdout = ExtractParams(data_object, 1); + auto process_stdout = ExtractParams(data_object, 1); auto callback = ExtractParams(data_object, 2); @@ -82,15 +76,15 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) GF_CORE_LOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); - if (!data_object->Check, + if (!data_object->Check, GpgCommandExecutorInteractor, GpgCommandExecutorCallback>()) { throw std::runtime_error("invalid data object size"); } // get arguments - auto cmd = ExtractParams(data_object, 0); - auto arguments = ExtractParams>(data_object, 1); + auto cmd = ExtractParams(data_object, 0); + auto arguments = ExtractParams>(data_object, 1); auto interact_func = ExtractParams(data_object, 2); auto callback = ExtractParams(data_object, 3); @@ -103,12 +97,12 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) // set process channel mode // this is to make sure we can get all output from stdout and stderr cmd_process->setProcessChannelMode(QProcess::MergedChannels); - cmd_process->setProgram(QString::fromStdString(cmd)); + cmd_process->setProgram(cmd); // set arguments QStringList q_arguments; for (const auto &argument : arguments) { - q_arguments.append(QString::fromStdString(argument)); + q_arguments.append(argument); } cmd_process->setArguments(q_arguments); @@ -138,8 +132,7 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) cmd_process->start(); cmd_process->waitForFinished(); - std::string process_stdout = - cmd_process->readAllStandardOutput().toStdString(); + QString process_stdout = cmd_process->readAllStandardOutput(); int exit_code = cmd_process->exitCode(); GF_CORE_LOG_DEBUG( @@ -160,17 +153,14 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) }; return new Thread::Task( - std::move(runner), - (boost::format("GpgCommamdExecutor(%1%){%2%}") % cmd % joined_argument) - .str(), + std::move(runner), QString("GpgCommamdExecutor(%1){%2}").arg(cmd), TransferParams(cmd, arguments, interact_function, cmd_executor_callback), std::move(result_callback)); } GpgCommandExecutor::ExecuteContext::ExecuteContext( - std::string cmd, std::vector arguments, - GpgCommandExecutorCallback callback, Module::TaskRunnerPtr task_runner, - GpgCommandExecutorInteractor int_func) + QString cmd, QList arguments, GpgCommandExecutorCallback callback, + Module::TaskRunnerPtr task_runner, GpgCommandExecutorInteractor int_func) : cmd(std::move(cmd)), arguments(std::move(arguments)), cb_func(std::move(callback)), -- cgit v1.2.3 From 6983b5c1dd82d159236ebd06cf17f071cc9c1ee9 Mon Sep 17 00:00:00 2001 From: saturneric Date: Fri, 12 Jan 2024 23:08:38 +0800 Subject: refactor: remove boost and use QString instead of std::filesystem::path --- src/core/function/gpg/GpgCommandExecutor.cpp | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 713d9aba..8246e6a1 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -76,15 +76,14 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) GF_CORE_LOG_DEBUG("process runner called, data object size: {}", data_object->GetObjectSize()); - if (!data_object->Check, - GpgCommandExecutorInteractor, + if (!data_object->Check()) { throw std::runtime_error("invalid data object size"); } // get arguments auto cmd = ExtractParams(data_object, 0); - auto arguments = ExtractParams>(data_object, 1); + auto arguments = ExtractParams(data_object, 1); auto interact_func = ExtractParams(data_object, 2); auto callback = ExtractParams(data_object, 3); -- cgit v1.2.3 From 4994f4eaa1211d402b791660ad6221154a4c2405 Mon Sep 17 00:00:00 2001 From: saturneric Date: Tue, 16 Jan 2024 11:49:50 +0800 Subject: fix: make task and threading system safer --- src/core/function/gpg/GpgCommandExecutor.cpp | 2 -- 1 file changed, 2 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 8246e6a1..b51db152 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -27,8 +27,6 @@ */ #include "GpgCommandExecutor.h" -#include - #include "core/function/basic/GpgFunctionObject.h" #include "core/model/DataObject.h" #include "core/module/Module.h" -- cgit v1.2.3 From 42fa750ae02d86e619114b2e57a0168f6bda60aa Mon Sep 17 00:00:00 2001 From: saturneric Date: Wed, 17 Jan 2024 02:03:08 +0800 Subject: fix: solve the gnupg tab options info not shown issue --- src/core/function/gpg/GpgCommandExecutor.cpp | 31 +++++++--------------------- 1 file changed, 8 insertions(+), 23 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index b51db152..886c70db 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -185,13 +185,10 @@ void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { // to arvoid dead lock issue we need to check if current thread is the same as // target thread. if it is, we can't call exec() because it will block the // current thread. - if (QThread::currentThread()->currentThreadId() != - target_task_runner->GetThread()->currentThreadId()) { - GF_CORE_LOG_TRACE("blocking until gpg command finish..."); - // block until task finished - // this is to keep reference vaild until task finished - looper.exec(); - } + GF_CORE_LOG_TRACE("blocking until gpg command finish..."); + // block until task finished + // this is to keep reference vaild until task finished + looper.exec(); } void GpgCommandExecutor::ExecuteConcurrentlyAsync(ExecuteContexts contexts) { @@ -217,8 +214,6 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { auto remaining_tasks = contexts.size(); Thread::TaskRunnerPtr target_task_runner = nullptr; - bool need_looper = false; - for (auto &context : contexts) { const auto &cmd = context.cmd; GF_CORE_LOG_DEBUG("gpg concurrently called cmd: {}", cmd); @@ -243,22 +238,12 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { } target_task_runner->PostTask(task); - - // to arvoid dead lock issue we need to check if current thread is the same - // as target thread. if it is, we can't call exec() because it will block - // the current thread. - if (QThread::currentThread()->currentThreadId() != - target_task_runner->GetThread()->currentThreadId()) { - need_looper = true; - } } - if (need_looper) { - GF_CORE_LOG_TRACE("blocking until concurrent gpg commands finish..."); - // block until task finished - // this is to keep reference vaild until task finished - looper.exec(); - } + GF_CORE_LOG_TRACE("blocking until concurrent gpg commands finish..."); + // block until task finished + // this is to keep reference vaild until task finished + looper.exec(); } } // namespace GpgFrontend \ No newline at end of file -- cgit v1.2.3 From e352e8e6b8d03a24ef5d52eef3e4d370807b5bbd Mon Sep 17 00:00:00 2001 From: saturneric Date: Wed, 17 Jan 2024 19:39:47 +0800 Subject: fix: find and slove some bugs --- src/core/function/gpg/GpgCommandExecutor.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 886c70db..8c994515 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -27,7 +27,6 @@ */ #include "GpgCommandExecutor.h" -#include "core/function/basic/GpgFunctionObject.h" #include "core/model/DataObject.h" #include "core/module/Module.h" #include "core/thread/Task.h" @@ -53,7 +52,8 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) "data object args count of cmd executor result callback: {}", data_object->GetObjectSize()); if (!data_object->Check()) { - throw std::runtime_error("invalid data object size"); + GF_CORE_LOG_ERROR("data object checking failed"); + return; } auto exit_code = ExtractParams(data_object, 0); @@ -76,7 +76,8 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) if (!data_object->Check()) { - throw std::runtime_error("invalid data object size"); + GF_CORE_LOG_ERROR("data object checking failed"); + return -1; } // get arguments -- cgit v1.2.3 From 4133b5cc1abf297f0e2a85799ed02c8b88c4215a Mon Sep 17 00:00:00 2001 From: saturneric Date: Mon, 22 Jan 2024 20:47:00 +0800 Subject: fix: QStringList is not equal to QList --- src/core/function/gpg/GpgCommandExecutor.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) (limited to 'src/core/function/gpg/GpgCommandExecutor.cpp') diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp index 8c994515..6d24f9bd 100644 --- a/src/core/function/gpg/GpgCommandExecutor.cpp +++ b/src/core/function/gpg/GpgCommandExecutor.cpp @@ -156,15 +156,6 @@ auto BuildTaskFromExecCtx(const GpgCommandExecutor::ExecuteContext &context) std::move(result_callback)); } -GpgCommandExecutor::ExecuteContext::ExecuteContext( - QString cmd, QList arguments, GpgCommandExecutorCallback callback, - Module::TaskRunnerPtr task_runner, GpgCommandExecutorInteractor int_func) - : cmd(std::move(cmd)), - arguments(std::move(arguments)), - cb_func(std::move(callback)), - int_func(std::move(int_func)), - task_runner(std::move(task_runner)) {} - void GpgCommandExecutor::ExecuteSync(ExecuteContext context) { Thread::Task *task = BuildTaskFromExecCtx(context); @@ -247,4 +238,13 @@ void GpgCommandExecutor::ExecuteConcurrentlySync(ExecuteContexts contexts) { looper.exec(); } +GpgCommandExecutor::ExecuteContext::ExecuteContext( + QString cmd, QStringList arguments, GpgCommandExecutorCallback callback, + Module::TaskRunnerPtr task_runner, GpgCommandExecutorInteractor int_func) + : cmd(std::move(cmd)), + arguments(std::move(arguments)), + cb_func(std::move(callback)), + int_func(std::move(int_func)), + task_runner(std::move(task_runner)) {} + } // namespace GpgFrontend \ No newline at end of file -- cgit v1.2.3