Merge pull request verilog-to-routing#3075 from w0lek/hotfix_win32_sockpp_and_vtr_enum_collisions

Hotfix win32 sockpp and vtr enum collisions

Author: AlexandreSinger

vpr/src/server/gateio.cpp

@@ -6,59 +6,17 @@
 #include "commconstants.h"
 #include "convertutils.h"
 
-namespace server {
-
-GateIO::GateIO() {
-    m_is_running.store(false);
-}
-
-GateIO::~GateIO() {
-    stop();
-}
+#include "sockpp/tcp6_acceptor.h"
 
-void GateIO::start(int port_num) {
-    if (!m_is_running.load()) {
-        m_port_num = port_num;
-        VTR_LOG("starting server");
-        m_is_running.store(true);
-        m_thread = std::thread(&GateIO::start_listening, this);
-    }
-}
-
-void GateIO::stop() {
-    if (m_is_running.load()) {
-        m_is_running.store(false);
-        if (m_thread.joinable()) {
-            m_thread.join();
-        }
-    }
-}
-
-void GateIO::take_received_tasks(std::vector<TaskPtr>& tasks) {
-    std::unique_lock<std::mutex> lock(m_tasks_mutex);
-    for (TaskPtr& task : m_received_tasks) {
-        m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "for processing");
-        tasks.push_back(std::move(task));
-    }
-    m_received_tasks.clear();
-}
-
-void GateIO::move_tasks_to_send_queue(std::vector<TaskPtr>& tasks) {
-    std::unique_lock<std::mutex> lock(m_tasks_mutex);
-    for (TaskPtr& task : tasks) {
-        m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "finished", (task->has_error() ? "with error" : "successfully"), task->error(), "to send queue");
-        m_send_tasks.push_back(std::move(task));
-    }
-    tasks.clear();
-}
+namespace server {
 
-GateIO::ActivityStatus GateIO::check_client_connection(sockpp::tcp6_acceptor& tcp_server, std::optional<sockpp::tcp6_socket>& client_opt) {
+static ActivityStatus check_client_connection(sockpp::tcp6_acceptor& tcp_server, std::optional<sockpp::tcp6_socket>& client_opt, TLogger& logger) {
     ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
 
     sockpp::inet6_address peer;
     sockpp::tcp6_socket client = tcp_server.accept(&peer);
     if (client) {
-        m_logger.queue(LogLevel::Info, "client", client.address().to_string(), "connection accepted");
+        logger.queue(LogLevel::Info, "client", client.address().to_string(), "connection accepted");
         client.set_non_blocking(true);
         client_opt = std::move(client);
 
@@ -68,67 +26,67 @@ GateIO::ActivityStatus GateIO::check_client_connection(sockpp::tcp6_acceptor& tc
     return status;
 }
 
-GateIO::ActivityStatus GateIO::handle_sending_data(sockpp::tcp6_socket& client) {
+static ActivityStatus handle_sending_data(sockpp::tcp6_socket& client, std::mutex& tasks_mutex, std::vector<TaskPtr>& send_tasks, TLogger& logger) {
     ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
-    std::unique_lock<std::mutex> lock(m_tasks_mutex);
+    std::unique_lock<std::mutex> lock(tasks_mutex);
 
-    if (!m_send_tasks.empty()) {
-        const TaskPtr& task = m_send_tasks.at(0);
+    if (!send_tasks.empty()) {
+        const TaskPtr& task = send_tasks.at(0);
         try {
             std::size_t bytes_to_send = std::min(CHUNK_MAX_BYTES_NUM, task->response_buffer().size());
             std::size_t bytes_sent = client.write_n(task->response_buffer().data(), bytes_to_send);
             if (bytes_sent <= task->orig_reponse_bytes_num()) {
                 task->chop_num_sent_bytes_from_response_buffer(bytes_sent);
-                m_logger.queue(LogLevel::Detail,
-                               "sent chunk:", get_pretty_size_str_from_bytes_num(bytes_sent),
-                               "from", get_pretty_size_str_from_bytes_num(task->orig_reponse_bytes_num()),
-                               "left:", get_pretty_size_str_from_bytes_num(task->response_buffer().size()));
+                logger.queue(LogLevel::Detail,
+                             "sent chunk:", get_pretty_size_str_from_bytes_num(bytes_sent),
+                             "from", get_pretty_size_str_from_bytes_num(task->orig_reponse_bytes_num()),
+                             "left:", get_pretty_size_str_from_bytes_num(task->response_buffer().size()));
                 status = ActivityStatus::CLIENT_ACTIVITY;
             }
         } catch (...) {
-            m_logger.queue(LogLevel::Detail, "error while writing chunk");
+            logger.queue(LogLevel::Detail, "error while writing chunk");
             status = ActivityStatus::COMMUNICATION_PROBLEM;
         }
 
         if (task->is_response_fully_sent()) {
-            m_logger.queue(LogLevel::Info, "sent:", task->telegram_header().info(), task->info());
+            logger.queue(LogLevel::Info, "sent:", task->telegram_header().info(), task->info());
         }
     }
 
     // remove reported tasks
-    std::size_t tasks_num_before_removing = m_send_tasks.size();
+    std::size_t tasks_num_before_removing = send_tasks.size();
 
-    auto partition_iter = std::partition(m_send_tasks.begin(), m_send_tasks.end(),
+    auto partition_iter = std::partition(send_tasks.begin(), send_tasks.end(),
                                          [](const TaskPtr& task) { return !task->is_response_fully_sent(); });
-    m_send_tasks.erase(partition_iter, m_send_tasks.end());
-    bool is_removing_took_place = tasks_num_before_removing != m_send_tasks.size();
-    if (!m_send_tasks.empty() && is_removing_took_place) {
-        m_logger.queue(LogLevel::Detail, "left tasks num to send ", m_send_tasks.size());
+    send_tasks.erase(partition_iter, send_tasks.end());
+    bool is_removing_took_place = tasks_num_before_removing != send_tasks.size();
+    if (!send_tasks.empty() && is_removing_took_place) {
+        logger.queue(LogLevel::Detail, "left tasks num to send ", send_tasks.size());
     }
 
     return status;
 }
 
-GateIO::ActivityStatus GateIO::handle_receiving_data(sockpp::tcp6_socket& client, comm::TelegramBuffer& telegram_buff, std::string& received_message) {
+static ActivityStatus handle_receiving_data(sockpp::tcp6_socket& client, comm::TelegramBuffer& telegram_buff, std::string& received_message, TLogger& logger) {
     ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
     std::size_t bytes_actually_received{0};
     try {
         bytes_actually_received = client.read_n(&received_message[0], CHUNK_MAX_BYTES_NUM);
     } catch (...) {
-        m_logger.queue(LogLevel::Error, "fail to receiving");
+        logger.queue(LogLevel::Error, "fail to receiving");
         status = ActivityStatus::COMMUNICATION_PROBLEM;
     }
 
     if ((bytes_actually_received > 0) && (bytes_actually_received <= CHUNK_MAX_BYTES_NUM)) {
-        m_logger.queue(LogLevel::Detail, "received chunk:", get_pretty_size_str_from_bytes_num(bytes_actually_received));
+        logger.queue(LogLevel::Detail, "received chunk:", get_pretty_size_str_from_bytes_num(bytes_actually_received));
         telegram_buff.append(comm::ByteArray{received_message.c_str(), bytes_actually_received});
         status = ActivityStatus::CLIENT_ACTIVITY;
     }
 
     return status;
 }
 
-GateIO::ActivityStatus GateIO::handle_telegrams(std::vector<comm::TelegramFramePtr>& telegram_frames, comm::TelegramBuffer& telegram_buff) {
+static ActivityStatus handle_telegrams(std::vector<comm::TelegramFramePtr>& telegram_frames, comm::TelegramBuffer& telegram_buff, std::mutex& tasks_mutex, std::vector<TaskPtr>& received_tasks, TLogger& logger) {
     ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
     telegram_frames.clear();
     telegram_buff.take_telegram_frames(telegram_frames);
@@ -137,32 +95,32 @@ GateIO::ActivityStatus GateIO::handle_telegrams(std::vector<comm::TelegramFrameP
         std::string message{telegram_frame->body};
         bool is_echo_telegram = false;
         if ((message.size() == comm::ECHO_TELEGRAM_BODY.size()) && (message == comm::ECHO_TELEGRAM_BODY)) {
-            m_logger.queue(LogLevel::Detail, "received", comm::ECHO_TELEGRAM_BODY);
+            logger.queue(LogLevel::Detail, "received", comm::ECHO_TELEGRAM_BODY);
             is_echo_telegram = true;
             status = ActivityStatus::CLIENT_ACTIVITY;
         }
 
         if (!is_echo_telegram) {
-            m_logger.queue(LogLevel::Detail, "received composed", get_pretty_size_str_from_bytes_num(message.size()), ":", get_truncated_middle_str(message));
+            logger.queue(LogLevel::Detail, "received composed", get_pretty_size_str_from_bytes_num(message.size()), ":", get_truncated_middle_str(message));
             std::optional<int> job_id_opt = comm::TelegramParser::try_extract_field_job_id(message);
             std::optional<int> cmd_opt = comm::TelegramParser::try_extract_field_cmd(message);
             std::optional<std::string> options_opt = comm::TelegramParser::try_extract_field_options(message);
             if (job_id_opt && cmd_opt && options_opt) {
                 TaskPtr task = std::make_unique<Task>(job_id_opt.value(), static_cast<comm::CMD>(cmd_opt.value()), options_opt.value());
                 const comm::TelegramHeader& header = telegram_frame->header;
-                m_logger.queue(LogLevel::Info, "received:", header.info(), task->info(/*skipDuration*/ true));
-                std::unique_lock<std::mutex> lock(m_tasks_mutex);
-                m_received_tasks.push_back(std::move(task));
+                logger.queue(LogLevel::Info, "received:", header.info(), task->info(/*skipDuration*/ true));
+                std::unique_lock<std::mutex> lock(tasks_mutex);
+                received_tasks.push_back(std::move(task));
             } else {
-                m_logger.queue(LogLevel::Error, "broken telegram detected, fail extract options from", message);
+                logger.queue(LogLevel::Error, "broken telegram detected, fail extract options from", message);
             }
         }
     }
 
     return status;
 }
 
-GateIO::ActivityStatus GateIO::handle_client_alive_tracker(sockpp::tcp6_socket& client, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr) {
+static ActivityStatus handle_client_alive_tracker(sockpp::tcp6_socket& client, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr, TLogger& logger) {
     ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
     if (client_alive_tracker_ptr) {
         /// handle sending echo to client
@@ -173,26 +131,26 @@ GateIO::ActivityStatus GateIO::handle_client_alive_tracker(sockpp::tcp6_socket&
             try {
                 std::size_t bytes_sent = client.write(message);
                 if (bytes_sent == message.size()) {
-                    m_logger.queue(LogLevel::Detail, "sent", comm::ECHO_TELEGRAM_BODY);
+                    logger.queue(LogLevel::Detail, "sent", comm::ECHO_TELEGRAM_BODY);
                     client_alive_tracker_ptr->on_echo_sent();
                 }
             } catch (...) {
-                m_logger.queue(LogLevel::Debug, "fail to sent", comm::ECHO_TELEGRAM_BODY);
+                logger.queue(LogLevel::Debug, "fail to sent", comm::ECHO_TELEGRAM_BODY);
                 status = ActivityStatus::COMMUNICATION_PROBLEM;
             }
         }
 
         /// handle client timeout
         if (client_alive_tracker_ptr->is_client_timeout()) {
-            m_logger.queue(LogLevel::Error, "client didn't respond too long");
+            logger.queue(LogLevel::Error, "client didn't respond too long");
             status = ActivityStatus::COMMUNICATION_PROBLEM;
         }
     }
 
     return status;
 }
 
-void GateIO::handle_activity_status(ActivityStatus status, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr, bool& is_communication_problem_detected) {
+static void handle_activity_status(ActivityStatus status, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr, bool& is_communication_problem_detected) {
     if (status == ActivityStatus::CLIENT_ACTIVITY) {
         if (client_alive_tracker_ptr) {
             client_alive_tracker_ptr->on_client_activity();
@@ -202,9 +160,54 @@ void GateIO::handle_activity_status(ActivityStatus status, std::unique_ptr<Clien
     }
 }
 
+GateIO::GateIO() {
+    m_is_running.store(false);
+}
+
+GateIO::~GateIO() {
+    stop();
+}
+
+void GateIO::start(int port_num) {
+    if (!m_is_running.load()) {
+        m_port_num = port_num;
+        VTR_LOG("starting server");
+        m_is_running.store(true);
+        m_thread = std::thread(&GateIO::start_listening, this);
+    }
+}
+
+void GateIO::stop() {
+    if (m_is_running.load()) {
+        m_is_running.store(false);
+        if (m_thread.joinable()) {
+            m_thread.join();
+        }
+    }
+}
+
+void GateIO::take_received_tasks(std::vector<TaskPtr>& tasks) {
+    std::unique_lock<std::mutex> lock(m_tasks_mutex);
+    for (TaskPtr& task : m_received_tasks) {
+        m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "for processing");
+        tasks.push_back(std::move(task));
+    }
+    m_received_tasks.clear();
+}
+
+void GateIO::move_tasks_to_send_queue(std::vector<TaskPtr>& tasks) {
+    std::unique_lock<std::mutex> lock(m_tasks_mutex);
+    for (TaskPtr& task : tasks) {
+        m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "finished", (task->has_error() ? "with error" : "successfully"), task->error(), "to send queue");
+        m_send_tasks.push_back(std::move(task));
+    }
+    tasks.clear();
+}
+
 void GateIO::start_listening() {
 #ifdef ENABLE_CLIENT_ALIVE_TRACKER
-    std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr = std::make_unique<ClientAliveTracker>(std::chrono::milliseconds{5000}, std::chrono::milliseconds{20000});
+    std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr =
+        std::make_unique<ClientAliveTracker>(std::chrono::milliseconds{5000}, std::chrono::milliseconds{20000});
 #else
     std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr;
 #endif
@@ -232,7 +235,7 @@ void GateIO::start_listening() {
         bool is_communication_problem_detected = false;
 
         if (!client_opt) {
-            ActivityStatus status = check_client_connection(tcp_server, client_opt);
+            ActivityStatus status = check_client_connection(tcp_server, client_opt, m_logger);
             if (status == ActivityStatus::CLIENT_ACTIVITY) {
                 if (client_alive_tracker_ptr) {
                     client_alive_tracker_ptr->reset();
@@ -244,15 +247,15 @@ void GateIO::start_listening() {
             sockpp::tcp6_socket& client = client_opt.value(); // shortcut
 
             /// handle sending
-            ActivityStatus status = handle_sending_data(client);
+            ActivityStatus status = handle_sending_data(client, m_tasks_mutex, m_send_tasks, m_logger);
             handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
 
             /// handle receiving
-            status = handle_receiving_data(client, telegram_buff, received_message);
+            status = handle_receiving_data(client, telegram_buff, received_message, m_logger);
             handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
 
             /// handle telegrams
-            status = handle_telegrams(telegram_frames, telegram_buff);
+            status = handle_telegrams(telegram_frames, telegram_buff, m_tasks_mutex, m_received_tasks, m_logger);
             handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
 
             // forward telegramBuffer errors
@@ -263,7 +266,7 @@ void GateIO::start_listening() {
             }
 
             /// handle client alive tracker
-            status = handle_client_alive_tracker(client, client_alive_tracker_ptr);
+            status = handle_client_alive_tracker(client, client_alive_tracker_ptr, m_logger);
             handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
 
             /// handle communication problem