refactor event system

repertory/librepertory/include/drives/remote/remote_server_base.hpp

@@ -58,7 +58,10 @@ public:
         drive_(drv),
         mount_location_(std::move(mount_location)),
         client_pool_(config.get_remote_mount().client_pool_size) {
-    event_system::instance().raise<service_start_begin>("remote_server_base");
+    REPERTORY_USES_FUNCTION_NAME();
+
+    event_system::instance().raise<service_start_begin>(function_name,
+                                                        "remote_server_base");
     handler_lookup_.insert(
         {"::winfsp_can_delete",
          [this](std::uint32_t, const std::string &, std::uint64_t,
@@ -1375,7 +1378,8 @@ public:
                                        method, request, response,
                                        message_complete);
         });
-    event_system::instance().raise<service_start_end>("remote_server_base");
+    event_system::instance().raise<service_start_end>(function_name,
+                                                      "remote_server_base");
   }
 
   ~remote_server_base() override {

repertory/librepertory/src/comm/packet/client_pool.cpp

@@ -46,7 +46,8 @@ void client_pool::pool::execute(
 client_pool::pool::pool(std::uint8_t pool_size) {
   REPERTORY_USES_FUNCTION_NAME();
 
-  event_system::instance().raise<service_start_begin>("client_pool");
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "client_pool");
 
   for (std::uint8_t i = 0U; i < pool_size; i++) {
     pool_queues_.emplace_back(std::make_unique<work_queue>());
@@ -109,7 +110,8 @@ client_pool::pool::pool(std::uint8_t pool_size) {
     });
   }
 
-  event_system::instance().raise<service_start_end>("client_pool");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "client_pool");
 }
 
 void client_pool::pool::shutdown() {

repertory/librepertory/src/comm/packet/packet_server.cpp

@@ -40,9 +40,13 @@ packet_server::packet_server(std::uint16_t port, std::string token,
     : encryption_token_(std::move(token)),
       closed_(std::move(closed)),
       message_handler_(std::move(message_handler)) {
-  event_system::instance().raise<service_start_begin>("packet_server");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "packet_server");
   initialize(port, pool_size);
-  event_system::instance().raise<service_start_end>("packet_server");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "packet_server");
 }
 
 packet_server::~packet_server() {

repertory/librepertory/src/file_manager/file_manager.cpp

@@ -848,7 +848,8 @@ void file_manager::start() {
     return;
   }
 
-  event_system::instance().raise<service_start_begin>("file_manager");
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "file_manager");
   stop_requested_ = false;
 
   polling::instance().set_callback({
@@ -859,7 +860,8 @@ void file_manager::start() {
 
   if (provider_.is_read_only()) {
     stop_requested_ = false;
-    event_system::instance().raise<service_start_end>("file_manager");
+    event_system::instance().raise<service_start_end>(function_name,
+                                                      "file_manager");
     return;
   }
 
@@ -919,7 +921,8 @@ void file_manager::start() {
   }
 
   upload_thread_ = std::make_unique<std::thread>([this] { upload_handler(); });
-  event_system::instance().raise<service_start_end>("file_manager");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "file_manager");
 }
 
 void file_manager::stop() {

repertory/librepertory/src/providers/encrypt/encrypt_provider.cpp

@@ -868,7 +868,8 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
     return false;
   }
 
-  event_system::instance().raise<service_start_begin>("encrypt_provider");
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "encrypt_provider");
   db_ = create_file_db(config_);
 
   std::string source_path;
@@ -905,7 +906,8 @@ auto encrypt_provider::start(api_item_added_callback /*api_item_added*/,
       [this](auto &&stop_requested) { remove_deleted_files(stop_requested); },
   });
 
-  event_system::instance().raise<service_start_end>("encrypt_provider");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "encrypt_provider");
   return true;
 }
 

repertory/librepertory/src/providers/s3/s3_provider.cpp

@@ -1040,12 +1040,16 @@ auto s3_provider::set_meta_key(const std::string &api_path,
 
 auto s3_provider::start(api_item_added_callback api_item_added,
                         i_file_manager *mgr) -> bool {
-  event_system::instance().raise<service_start_begin>("s3_provider");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "s3_provider");
   s3_config_ = get_config().get_s3_config();
   get_comm().enable_s3_path_style(s3_config_.use_path_style);
   auto ret = base_provider::start(api_item_added, mgr);
-  event_system::instance().raise<service_start_end>("s3_provider");
+  event_system::instance().raise<service_start_end>(function_name,
-  return ret
+                                                    "s3_provider");
+  return ret;
 }
 
 void s3_provider::stop() {

repertory/librepertory/src/providers/sia/sia_provider.cpp

@@ -741,10 +741,14 @@ auto sia_provider::rename_file(const std::string &from_api_path,
 
 auto sia_provider::start(api_item_added_callback api_item_added,
                          i_file_manager *mgr) -> bool {
-  event_system::instance().raise<service_start_begin>("sia_provider");
+  REPERTORY_USES_FUNCTION_NAME();
+
+  event_system::instance().raise<service_start_begin>(function_name,
+                                                      "sia_provider");
   sia_config_ = get_config().get_sia_config();
   auto ret = base_provider::start(api_item_added, mgr);
-  event_system::instance().raise<service_start_end>("sia_provider");
+  event_system::instance().raise<service_start_end>(function_name,
+                                                    "sia_provider");
   return ret;
 }
 

repertory/librepertory/src/rpc/server/server.cpp

@@ -146,7 +146,7 @@ void server::start() {
     return;
   }
 
-  event_system::instance().raise<service_start_begin>("server");
+  event_system::instance().raise<service_start_begin>(function_name, "server");
 
   server_ = std::make_unique<httplib::Server>();
 
@@ -185,7 +185,7 @@ void server::start() {
 
   server_thread_ = std::make_unique<std::thread>(
       [this]() { server_->listen("127.0.0.1", config_.get_api_port()); });
-  event_system::instance().raise<service_start_end>("server");
+  event_system::instance().raise<service_start_end>(function_name, "server");
 }
 
 void server::stop() {

repertory/librepertory/src/utils/polling.cpp

@@ -97,12 +97,14 @@ void polling::set_callback(const polling_item &item) {
 }
 
 void polling::start(app_config *config) {
+  REPERTORY_USES_FUNCTION_NAME();
+
   mutex_lock lock(start_stop_mutex_);
   if (frequency_threads_.at(0U)) {
     return;
   }
 
-  event_system::instance().raise<service_start_begin>("polling");
+  event_system::instance().raise<service_start_begin>(function_name, "polling");
   config_ = config;
   stop_requested_ = false;
 
@@ -141,7 +143,7 @@ void polling::start(app_config *config) {
         this->frequency_thread([]() -> std::uint32_t { return 1U; },
                                frequency::second);
       });
-  event_system::instance().raise<service_start_end>("polling");
+  event_system::instance().raise<service_start_end>(function_name, "polling");
 }
 
 void polling::stop() {

repertory/librepertory/src/utils/single_thread_service_base.cpp

@@ -40,6 +40,8 @@ void single_thread_service_base::notify_all() const {
 }
 
 void single_thread_service_base::start() {
+  REPERTORY_USES_FUNCTION_NAME();
+
   mutex_lock lock(mtx_);
   if (thread_) {
     return;
@@ -48,8 +50,10 @@ void single_thread_service_base::start() {
   stop_requested_ = false;
   on_start();
   thread_ = std::make_unique<std::thread>([this]() {
-    event_system::instance().raise<service_start_begin>(service_name_);
+    event_system::instance().raise<service_start_begin>(function_name,
-    event_system::instance().raise<service_start_end>(service_name_);
+                                                        service_name_);
+    event_system::instance().raise<service_start_end>(function_name,
+                                                      service_name_);
     while (not get_stop_requested()) {
       service_function();
     }