feat: change the log style in source files

7 files changed, 56 insertions, 58 deletions

diff --git a/src/core/function/gpg/GpgAdvancedOperator.cpp b/src/core/function/gpg/GpgAdvancedOperator.cpp
index 0ec447fe..dc48410e 100644
--- a/src/core/function/gpg/GpgAdvancedOperator.cpp
+++ b/src/core/function/gpg/GpgAdvancedOperator.cpp
@@ -57,8 +57,9 @@ bool GpgFrontend::GpgAdvancedOperator::ReloadGpgComponents() {
         if (exit_code == 0) {
           success = true;
         } else {
-          LOG(ERROR) << "gpgconf execute error, process stderr:" << p_err
-                     << ", process stdout:" << p_out;
+          SPDLOG_ERROR(
+              "gpgconf execute error, process stderr: {}, process stdout: {}",
+              p_err, p_out);
           return;
         }
       });
@@ -74,8 +75,9 @@ bool GpgFrontend::GpgAdvancedOperator::RestartGpgComponents() {
         if (exit_code == 0) {
           success = true;
         } else {
-          LOG(ERROR) << "gpgconf execute error, process stderr:" << p_err
-                     << ", process stdout:" << p_out;
+          SPDLOG_ERROR(
+              "gpgconf execute error, process stderr: {}, process stdout: {}",
+              p_err, p_out);
           return;
         }
       });
@@ -87,8 +89,9 @@ bool GpgFrontend::GpgAdvancedOperator::RestartGpgComponents() {
           success = true;
         } else {
           success = false;
-          LOG(ERROR) << "gpgconf execute error, process stderr:" << p_err
-                     << ", process stdout:" << p_out;
+          SPDLOG_ERROR(
+              "gpgconf execute error, process stderr: {}, process stdout: {}",
+              p_err, p_out);
           return;
         }
       });
@@ -104,8 +107,9 @@ bool GpgFrontend::GpgAdvancedOperator::ResetConfigures() {
         if (exit_code == 0) {
           success = true;
         } else {
-          LOG(ERROR) << "gpgconf execute error, process stderr:" << p_err
-                     << ", process stdout:" << p_out;
+          SPDLOG_ERROR(
+              "gpgconf execute error, process stderr: {}, process stdout: {}",
+              p_err, p_out);
           return;
         }
       });
diff --git a/src/core/function/gpg/GpgBasicOperator.cpp b/src/core/function/gpg/GpgBasicOperator.cpp
index a2c5d81b..5f857375 100644
--- a/src/core/function/gpg/GpgBasicOperator.cpp
+++ b/src/core/function/gpg/GpgBasicOperator.cpp
@@ -178,15 +178,15 @@ gpgme_error_t GpgFrontend::GpgBasicOperator::EncryptSign(
 void GpgFrontend::GpgBasicOperator::SetSigners(KeyArgsList& signers) {
   gpgme_signers_clear(ctx_);
   for (const GpgKey& key : signers) {
-    DLOG(INFO) << "key" << key.GetFingerprint();
+    SPDLOG_INFO("key fpr: {}", key.GetFingerprint());
     if (key.IsHasActualSigningCapability()) {
-      DLOG(INFO) << "signer";
+      SPDLOG_INFO("signer");
       auto error = gpgme_signers_add(ctx_, gpgme_key_t(key));
       check_gpg_error(error);
     }
   }
   if (signers.size() != gpgme_signers_count(ctx_))
-    DLOG(INFO) << "No All Signers Added";
+    SPDLOG_INFO("not all signers added");
 }
 
 std::unique_ptr<GpgFrontend::KeyArgsList>
diff --git a/src/core/function/gpg/GpgCommandExecutor.cpp b/src/core/function/gpg/GpgCommandExecutor.cpp
index 0fe9b5c3..720388a0 100644
--- a/src/core/function/gpg/GpgCommandExecutor.cpp
+++ b/src/core/function/gpg/GpgCommandExecutor.cpp
@@ -37,12 +37,11 @@ void GpgFrontend::GpgCommandExecutor::Execute(
     std::string cmd, std::vector<std::string> arguments,
     std::function<void(int, std::string, std::string)> callback,
     std::function<void(QProcess *)> interact_func) {
-  LOG(INFO) << "called"
-            << "cmd" << cmd << "arguments size" << arguments.size();
+  SPDLOG_INFO("called cmd {} arguments size: {}", cmd, arguments.size());
 
   Thread::Task::TaskCallback result_callback =
       [](int rtn, Thread::Task::DataObjectPtr data_object) {
-        LOG(INFO) << "called";
+        SPDLOG_INFO("called");
 
         if (data_object->GetObjectSize() != 4)
           throw std::runtime_error("invalid data object size");
@@ -59,15 +58,15 @@ void GpgFrontend::GpgCommandExecutor::Execute(
 
   Thread::Task::TaskRunnable runner =
       [](GpgFrontend::Thread::Task::DataObjectPtr data_object) -> int {
-    LOG(INFO) << "process runner called, data object size"
-              << data_object->GetObjectSize();
+    SPDLOG_INFO("process runner called, data object size: {}",
+                data_object->GetObjectSize());
 
     if (data_object->GetObjectSize() != 4)
       throw std::runtime_error("invalid data object size");
 
     // get arguments
     auto cmd = data_object->PopObject<std::string>();
-    LOG(INFO) << "get cmd" << cmd;
+    SPDLOG_INFO("get cmd: {}", cmd);
     auto arguments = data_object->PopObject<std::vector<std::string>>();
     auto interact_func =
         data_object->PopObject<std::function<void(QProcess *)>>();
@@ -76,20 +75,20 @@ void GpgFrontend::GpgCommandExecutor::Execute(
     cmd_process->setProcessChannelMode(QProcess::MergedChannels);
 
     QObject::connect(cmd_process, &QProcess::started,
-                     []() -> void { LOG(INFO) << "process started"; });
+                     []() -> void { SPDLOG_INFO("process started"); });
     QObject::connect(
         cmd_process, &QProcess::readyReadStandardOutput,
         [interact_func, cmd_process]() { interact_func(cmd_process); });
     QObject::connect(cmd_process, &QProcess::errorOccurred, [=]() {
-      LOG(ERROR) << "error in executing command:" << cmd;
+      SPDLOG_ERROR("error in executing command: {}", cmd);
     });
     QObject::connect(cmd_process,
                      qOverload<int, QProcess::ExitStatus>(&QProcess::finished),
                      [=](int, QProcess::ExitStatus status) {
                        if (status == QProcess::NormalExit)
-                         LOG(INFO) << "succeed in executing command:" << cmd;
+                         SPDLOG_INFO("succeed in executing command: {}", cmd);
                        else
-                         LOG(WARNING) << "error in executing command:" << cmd;
+                         SPDLOG_WARN("error in executing command: {}", cmd);
                      });
 
     cmd_process->setProgram(QString::fromStdString(cmd));
@@ -99,7 +98,7 @@ void GpgFrontend::GpgCommandExecutor::Execute(
       q_arguments.append(QString::fromStdString(argument));
     cmd_process->setArguments(q_arguments);
 
-    LOG(INFO) << "process execute ready";
+    SPDLOG_INFO("process execute ready");
 
     cmd_process->start();
     cmd_process->waitForFinished(30);
diff --git a/src/core/function/gpg/GpgKeyGetter.cpp b/src/core/function/gpg/GpgKeyGetter.cpp
index 571e8797..0cb418a7 100644
--- a/src/core/function/gpg/GpgKeyGetter.cpp
+++ b/src/core/function/gpg/GpgKeyGetter.cpp
@@ -35,18 +35,16 @@
 #include <utility>
 
 #include "GpgConstants.h"
-#include "easylogging++.h"
 #include "model/GpgKey.h"
 
 GpgFrontend::GpgKeyGetter::GpgKeyGetter(int channel)
     : SingletonFunctionObject<GpgKeyGetter>(channel) {
-  LOG(INFO) << "called"
-            << "channel:" << channel;
+  SPDLOG_INFO("called channel: {}", channel);
 }
 
 GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetKey(const std::string& fpr,
                                                       bool use_cache) {
-  LOG(INFO) << "called";
+  SPDLOG_INFO("called");
 
   // find in cache first
   if (use_cache) {
@@ -57,7 +55,7 @@ GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetKey(const std::string& fpr,
   gpgme_key_t _p_key = nullptr;
   gpgme_get_key(ctx_, fpr.c_str(), &_p_key, 1);
   if (_p_key == nullptr) {
-    DLOG(WARNING) << "GpgKeyGetter GetKey Private _p_key Null fpr" << fpr;
+    SPDLOG_WARN("GpgKeyGetter GetKey Private _p_key Null fpr", fpr);
     return GetPubkey(fpr);
   } else {
     return GpgKey(std::move(_p_key));
@@ -74,8 +72,7 @@ GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetPubkey(const std::string& fpr,
 
   gpgme_key_t _p_key = nullptr;
   gpgme_get_key(ctx_, fpr.c_str(), &_p_key, 0);
-  if (_p_key == nullptr)
-    DLOG(WARNING) << "GpgKeyGetter GetKey _p_key Null" << fpr;
+  if (_p_key == nullptr) SPDLOG_WARN("GpgKeyGetter GetKey _p_key Null", fpr);
   return GpgKey(std::move(_p_key));
 }
 
@@ -83,21 +80,19 @@ GpgFrontend::KeyLinkListPtr GpgFrontend::GpgKeyGetter::FetchKey() {
   // get the lock
   std::lock_guard<std::mutex> lock(keys_cache_mutex_);
 
-  LOG(INFO) << "GpgKeyGetter FetchKey"
-            << "channel id:" << GetChannel();
+  SPDLOG_INFO("channel id: {}", GetChannel());
 
   auto keys_list = std::make_unique<GpgKeyLinkList>();
 
   for (const auto& [key, value] : keys_cache_) {
-    LOG(INFO) << "FetchKey Id:" << value.GetId();
+    SPDLOG_INFO("fetch key id: {}", value.GetId());
     keys_list->push_back(value.Copy());
   }
   return keys_list;
 }
 
 void GpgFrontend::GpgKeyGetter::FlushKeyCache() {
-  LOG(INFO) << "called"
-            << "channel id: " << GetChannel();
+  SPDLOG_INFO("called channel id: {}", GetChannel());
 
   // clear the keys cache
   keys_cache_.clear();
@@ -125,13 +120,14 @@ void GpgFrontend::GpgKeyGetter::FlushKeyCache() {
         gpg_key = GetKey(gpg_key.GetId(), false);
       }
 
-      LOG(INFO) << "LoadKey Fpr:" << gpg_key.GetFingerprint()
-                << "Id:" << gpg_key.GetId();
+      SPDLOG_INFO("load key fpr: {} id: {}", gpg_key.GetFingerprint(),
+                  gpg_key.GetId());
       keys_cache_.insert({gpg_key.GetId(), std::move(gpg_key)});
     }
   }
 
-  LOG(INFO) << "cache address:" << &keys_cache_ << "object address" << this;
+  SPDLOG_INFO("cache address: {} object address: {}",
+              static_cast<void*>(&keys_cache_), static_cast<void*>(this));
 
   // for debug
   assert(check_gpg_error_2_err_code(err, GPG_ERR_EOF) == GPG_ERR_EOF);
diff --git a/src/core/function/gpg/GpgKeyImportExporter.cpp b/src/core/function/gpg/GpgKeyImportExporter.cpp
index 206282ae..dc744e09 100644
--- a/src/core/function/gpg/GpgKeyImportExporter.cpp
+++ b/src/core/function/gpg/GpgKeyImportExporter.cpp
@@ -91,8 +91,8 @@ bool GpgFrontend::GpgKeyImportExporter::ExportKeys(KeyIdArgsListPtr& uid_list,
 
   delete[] keys_array;
 
-  DLOG(INFO) << "exportKeys read_bytes"
-             << gpgme_data_seek(data_out, 0, SEEK_END);
+  SPDLOG_INFO("exportKeys read_bytes: {}",
+              gpgme_data_seek(data_out, 0, SEEK_END));
 
   auto temp_out_buffer = data_out.Read2Buffer();
 
@@ -123,7 +123,7 @@ bool GpgFrontend::GpgKeyImportExporter::ExportKeys(const KeyArgsList& keys,
  */
 bool GpgFrontend::GpgKeyImportExporter::ExportSecretKey(
     const GpgKey& key, ByteArrayPtr& out_buffer) const {
-  DLOG(INFO) << "Export Secret Key" << key.GetId().c_str();
+  SPDLOG_INFO("export secret key: {}", key.GetId().c_str());
 
   gpgme_key_t target_key[2] = {gpgme_key_t(key), nullptr};
 
@@ -144,8 +144,8 @@ bool GpgFrontend::GpgKeyImportExporter::ExportKey(
   GpgData data_out;
   auto err = gpgme_op_export(ctx_, key.GetId().c_str(), 0, data_out);
 
-  DLOG(INFO) << "exportKeys read_bytes"
-             << gpgme_data_seek(data_out, 0, SEEK_END);
+  SPDLOG_INFO("export keys read_bytes: {}",
+              gpgme_data_seek(data_out, 0, SEEK_END));
 
   auto temp_out_buffer = data_out.Read2Buffer();
   std::swap(out_buffer, temp_out_buffer);
@@ -159,7 +159,7 @@ bool GpgFrontend::GpgKeyImportExporter::ExportKeyOpenSSH(
   auto err = gpgme_op_export(ctx_, key.GetId().c_str(), GPGME_EXPORT_MODE_SSH,
                              data_out);
 
-  DLOG(INFO) << "read_bytes" << gpgme_data_seek(data_out, 0, SEEK_END);
+  SPDLOG_INFO("read_bytes: {}", gpgme_data_seek(data_out, 0, SEEK_END));
 
   auto temp_out_buffer = data_out.Read2Buffer();
   std::swap(out_buffer, temp_out_buffer);
@@ -173,7 +173,7 @@ bool GpgFrontend::GpgKeyImportExporter::ExportSecretKeyShortest(
   auto err = gpgme_op_export(ctx_, key.GetId().c_str(),
                              GPGME_EXPORT_MODE_MINIMAL, data_out);
 
-  DLOG(INFO) << "read_bytes" << gpgme_data_seek(data_out, 0, SEEK_END);
+  SPDLOG_INFO("read_bytes: {}", gpgme_data_seek(data_out, 0, SEEK_END));
 
   auto temp_out_buffer = data_out.Read2Buffer();
   std::swap(out_buffer, temp_out_buffer);
diff --git a/src/core/function/gpg/GpgKeyOpera.cpp b/src/core/function/gpg/GpgKeyOpera.cpp
index 08103bbb..00c0a6c8 100644
--- a/src/core/function/gpg/GpgKeyOpera.cpp
+++ b/src/core/function/gpg/GpgKeyOpera.cpp
@@ -59,7 +59,7 @@ void GpgFrontend::GpgKeyOpera::DeleteKeys(
                               GPGME_DELETE_ALLOW_SECRET | GPGME_DELETE_FORCE));
       assert(gpg_err_code(err) == GPG_ERR_NO_ERROR);
     } else {
-      LOG(WARNING) << "GpgKeyOpera DeleteKeys get key failed" << tmp;
+      SPDLOG_WARN("GpgKeyOpera DeleteKeys get key failed", tmp);
     }
   }
 }
@@ -84,7 +84,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::SetExpire(
         to_time_t(*expires) - system_clock::to_time_t(system_clock::now());
   }
 
-  LOG(INFO) << key.GetId() << subkey_fpr << expires_time;
+  SPDLOG_INFO(key.GetId(), subkey_fpr, expires_time);
 
   GpgError err;
   if (key.GetFingerprint() == subkey_fpr || subkey_fpr.empty())
@@ -116,7 +116,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
   const char* userid = userid_utf8.c_str();
   auto algo_utf8 = params->GetAlgo() + params->GetKeySizeStr();
 
-  LOG(INFO) << "params" << params->GetAlgo() << params->GetKeySizeStr();
+  SPDLOG_INFO("params: {} {}", params->GetAlgo(), params->GetKeySizeStr());
 
   const char* algo = algo_utf8.c_str();
   unsigned long expires = 0;
@@ -129,7 +129,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
 
   GpgError err;
 
-  LOG(INFO) << "ctx version" << ctx_.GetInfo(false).GnupgVersion;
+  SPDLOG_INFO("ctx version, {}", ctx_.GetInfo(false).GnupgVersion);
 
   if (ctx_.GetInfo(false).GnupgVersion >= "2.1.0") {
     unsigned int flags = 0;
@@ -141,7 +141,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
     if (params->IsNonExpired()) flags |= GPGME_CREATE_NOEXPIRE;
     if (params->IsNoPassPhrase()) flags |= GPGME_CREATE_NOPASSWD;
 
-    LOG(INFO) << "args: " << userid << algo << expires << flags;
+    SPDLOG_INFO("args: {}", userid, algo, expires, flags);
 
     err = gpgme_op_createkey(ctx_, userid, algo, 0, expires, nullptr, flags);
 
@@ -170,7 +170,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateKey(
 
     ss << "</GnupgKeyParms>";
 
-    DLOG(INFO) << "params" << std::endl << ss.str();
+    SPDLOG_INFO("params: {}", ss.str());
 
     err = gpgme_op_genkey(ctx_, ss.str().c_str(), nullptr, nullptr);
   }
@@ -193,9 +193,8 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateSubkey(
     const GpgKey& key, const std::unique_ptr<GenKeyInfo>& params) {
   if (!params->IsSubKey()) return GPG_ERR_CANCELED;
 
-  LOG(INFO) << "generate subkey"
-            << "algo" << params->GetAlgo() << "key size"
-            << params->GetKeySizeStr();
+  SPDLOG_INFO("generate subkey algo {} key size {}", params->GetAlgo(),
+              params->GetKeySizeStr());
 
   auto algo_utf8 = (params->GetAlgo() + params->GetKeySizeStr());
   const char* algo = algo_utf8.c_str();
@@ -216,8 +215,8 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateSubkey(
 
   flags |= GPGME_CREATE_NOPASSWD;
 
-  LOG(INFO) << "GpgFrontend::GpgKeyOpera::GenerateSubkey Args: " << key.GetId()
-            << algo << expires << flags;
+  SPDLOG_INFO("GpgFrontend::GpgKeyOpera::GenerateSubkey args: {} {} {} {}",
+              key.GetId(), algo, expires, flags);
 
   auto err =
       gpgme_op_createsubkey(ctx_, gpgme_key_t(key), algo, 0, expires, flags);
@@ -227,7 +226,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::GenerateSubkey(
 GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::ModifyPassword(
     const GpgFrontend::GpgKey& key) {
   if (ctx_.GetInfo(false).GnupgVersion < "2.0.15") {
-    LOG(ERROR) << _("operator not support");
+    SPDLOG_ERROR("operator not support");
     return GPG_ERR_NOT_SUPPORTED;
   }
   auto err = gpgme_op_passwd(ctx_, gpgme_key_t(key), 0);
@@ -236,7 +235,7 @@ GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::ModifyPassword(
 GpgFrontend::GpgError GpgFrontend::GpgKeyOpera::ModifyTOFUPolicy(
     const GpgFrontend::GpgKey& key, gpgme_tofu_policy_t tofu_policy) {
   if (ctx_.GetInfo(false).GnupgVersion < "2.1.10") {
-    LOG(ERROR) << _("operator not support");
+    SPDLOG_ERROR("operator not support");
     return GPG_ERR_NOT_SUPPORTED;
   }
   auto err = gpgme_op_tofu_policy(ctx_, gpgme_key_t(key), tofu_policy);
diff --git a/src/core/function/gpg/GpgUIDOperator.cpp b/src/core/function/gpg/GpgUIDOperator.cpp
index 33c29fa4..5b92b86d 100644
--- a/src/core/function/gpg/GpgUIDOperator.cpp
+++ b/src/core/function/gpg/GpgUIDOperator.cpp
@@ -65,7 +65,7 @@ bool GpgFrontend::GpgUIDOperator::AddUID(const GpgFrontend::GpgKey& key,
                                          const std::string& name,
                                          const std::string& comment,
                                          const std::string& email) {
-  LOG(INFO) << "GpgFrontend::UidOperator::AddUID" << name << comment << email;
+  SPDLOG_INFO("GpgFrontend::UidOperator::AddUID", name, comment, email);
   auto uid = boost::format("%1%(%2%)<%3%>") % name % comment % email;
   return AddUID(key, uid.str());
 }