Skip to content

Commit 6069ccc

Browse files
Merge pull request verilog-to-routing#3075 from w0lek/hotfix_win32_sockpp_and_vtr_enum_collisions
Hotfix win32 sockpp and vtr enum collisions
2 parents 3ed7c19 + e566a3c commit 6069ccc

File tree

2 files changed

+185
-193
lines changed

2 files changed

+185
-193
lines changed

vpr/src/server/gateio.cpp

Lines changed: 86 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -6,59 +6,17 @@
66
#include "commconstants.h"
77
#include "convertutils.h"
88

9-
namespace server {
10-
11-
GateIO::GateIO() {
12-
m_is_running.store(false);
13-
}
14-
15-
GateIO::~GateIO() {
16-
stop();
17-
}
9+
#include "sockpp/tcp6_acceptor.h"
1810

19-
void GateIO::start(int port_num) {
20-
if (!m_is_running.load()) {
21-
m_port_num = port_num;
22-
VTR_LOG("starting server");
23-
m_is_running.store(true);
24-
m_thread = std::thread(&GateIO::start_listening, this);
25-
}
26-
}
27-
28-
void GateIO::stop() {
29-
if (m_is_running.load()) {
30-
m_is_running.store(false);
31-
if (m_thread.joinable()) {
32-
m_thread.join();
33-
}
34-
}
35-
}
36-
37-
void GateIO::take_received_tasks(std::vector<TaskPtr>& tasks) {
38-
std::unique_lock<std::mutex> lock(m_tasks_mutex);
39-
for (TaskPtr& task : m_received_tasks) {
40-
m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "for processing");
41-
tasks.push_back(std::move(task));
42-
}
43-
m_received_tasks.clear();
44-
}
45-
46-
void GateIO::move_tasks_to_send_queue(std::vector<TaskPtr>& tasks) {
47-
std::unique_lock<std::mutex> lock(m_tasks_mutex);
48-
for (TaskPtr& task : tasks) {
49-
m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "finished", (task->has_error() ? "with error" : "successfully"), task->error(), "to send queue");
50-
m_send_tasks.push_back(std::move(task));
51-
}
52-
tasks.clear();
53-
}
11+
namespace server {
5412

55-
GateIO::ActivityStatus GateIO::check_client_connection(sockpp::tcp6_acceptor& tcp_server, std::optional<sockpp::tcp6_socket>& client_opt) {
13+
static ActivityStatus check_client_connection(sockpp::tcp6_acceptor& tcp_server, std::optional<sockpp::tcp6_socket>& client_opt, TLogger& logger) {
5614
ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
5715

5816
sockpp::inet6_address peer;
5917
sockpp::tcp6_socket client = tcp_server.accept(&peer);
6018
if (client) {
61-
m_logger.queue(LogLevel::Info, "client", client.address().to_string(), "connection accepted");
19+
logger.queue(LogLevel::Info, "client", client.address().to_string(), "connection accepted");
6220
client.set_non_blocking(true);
6321
client_opt = std::move(client);
6422

@@ -68,67 +26,67 @@ GateIO::ActivityStatus GateIO::check_client_connection(sockpp::tcp6_acceptor& tc
6826
return status;
6927
}
7028

71-
GateIO::ActivityStatus GateIO::handle_sending_data(sockpp::tcp6_socket& client) {
29+
static ActivityStatus handle_sending_data(sockpp::tcp6_socket& client, std::mutex& tasks_mutex, std::vector<TaskPtr>& send_tasks, TLogger& logger) {
7230
ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
73-
std::unique_lock<std::mutex> lock(m_tasks_mutex);
31+
std::unique_lock<std::mutex> lock(tasks_mutex);
7432

75-
if (!m_send_tasks.empty()) {
76-
const TaskPtr& task = m_send_tasks.at(0);
33+
if (!send_tasks.empty()) {
34+
const TaskPtr& task = send_tasks.at(0);
7735
try {
7836
std::size_t bytes_to_send = std::min(CHUNK_MAX_BYTES_NUM, task->response_buffer().size());
7937
std::size_t bytes_sent = client.write_n(task->response_buffer().data(), bytes_to_send);
8038
if (bytes_sent <= task->orig_reponse_bytes_num()) {
8139
task->chop_num_sent_bytes_from_response_buffer(bytes_sent);
82-
m_logger.queue(LogLevel::Detail,
83-
"sent chunk:", get_pretty_size_str_from_bytes_num(bytes_sent),
84-
"from", get_pretty_size_str_from_bytes_num(task->orig_reponse_bytes_num()),
85-
"left:", get_pretty_size_str_from_bytes_num(task->response_buffer().size()));
40+
logger.queue(LogLevel::Detail,
41+
"sent chunk:", get_pretty_size_str_from_bytes_num(bytes_sent),
42+
"from", get_pretty_size_str_from_bytes_num(task->orig_reponse_bytes_num()),
43+
"left:", get_pretty_size_str_from_bytes_num(task->response_buffer().size()));
8644
status = ActivityStatus::CLIENT_ACTIVITY;
8745
}
8846
} catch (...) {
89-
m_logger.queue(LogLevel::Detail, "error while writing chunk");
47+
logger.queue(LogLevel::Detail, "error while writing chunk");
9048
status = ActivityStatus::COMMUNICATION_PROBLEM;
9149
}
9250

9351
if (task->is_response_fully_sent()) {
94-
m_logger.queue(LogLevel::Info, "sent:", task->telegram_header().info(), task->info());
52+
logger.queue(LogLevel::Info, "sent:", task->telegram_header().info(), task->info());
9553
}
9654
}
9755

9856
// remove reported tasks
99-
std::size_t tasks_num_before_removing = m_send_tasks.size();
57+
std::size_t tasks_num_before_removing = send_tasks.size();
10058

101-
auto partition_iter = std::partition(m_send_tasks.begin(), m_send_tasks.end(),
59+
auto partition_iter = std::partition(send_tasks.begin(), send_tasks.end(),
10260
[](const TaskPtr& task) { return !task->is_response_fully_sent(); });
103-
m_send_tasks.erase(partition_iter, m_send_tasks.end());
104-
bool is_removing_took_place = tasks_num_before_removing != m_send_tasks.size();
105-
if (!m_send_tasks.empty() && is_removing_took_place) {
106-
m_logger.queue(LogLevel::Detail, "left tasks num to send ", m_send_tasks.size());
61+
send_tasks.erase(partition_iter, send_tasks.end());
62+
bool is_removing_took_place = tasks_num_before_removing != send_tasks.size();
63+
if (!send_tasks.empty() && is_removing_took_place) {
64+
logger.queue(LogLevel::Detail, "left tasks num to send ", send_tasks.size());
10765
}
10866

10967
return status;
11068
}
11169

112-
GateIO::ActivityStatus GateIO::handle_receiving_data(sockpp::tcp6_socket& client, comm::TelegramBuffer& telegram_buff, std::string& received_message) {
70+
static ActivityStatus handle_receiving_data(sockpp::tcp6_socket& client, comm::TelegramBuffer& telegram_buff, std::string& received_message, TLogger& logger) {
11371
ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
11472
std::size_t bytes_actually_received{0};
11573
try {
11674
bytes_actually_received = client.read_n(&received_message[0], CHUNK_MAX_BYTES_NUM);
11775
} catch (...) {
118-
m_logger.queue(LogLevel::Error, "fail to receiving");
76+
logger.queue(LogLevel::Error, "fail to receiving");
11977
status = ActivityStatus::COMMUNICATION_PROBLEM;
12078
}
12179

12280
if ((bytes_actually_received > 0) && (bytes_actually_received <= CHUNK_MAX_BYTES_NUM)) {
123-
m_logger.queue(LogLevel::Detail, "received chunk:", get_pretty_size_str_from_bytes_num(bytes_actually_received));
81+
logger.queue(LogLevel::Detail, "received chunk:", get_pretty_size_str_from_bytes_num(bytes_actually_received));
12482
telegram_buff.append(comm::ByteArray{received_message.c_str(), bytes_actually_received});
12583
status = ActivityStatus::CLIENT_ACTIVITY;
12684
}
12785

12886
return status;
12987
}
13088

131-
GateIO::ActivityStatus GateIO::handle_telegrams(std::vector<comm::TelegramFramePtr>& telegram_frames, comm::TelegramBuffer& telegram_buff) {
89+
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) {
13290
ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
13391
telegram_frames.clear();
13492
telegram_buff.take_telegram_frames(telegram_frames);
@@ -137,32 +95,32 @@ GateIO::ActivityStatus GateIO::handle_telegrams(std::vector<comm::TelegramFrameP
13795
std::string message{telegram_frame->body};
13896
bool is_echo_telegram = false;
13997
if ((message.size() == comm::ECHO_TELEGRAM_BODY.size()) && (message == comm::ECHO_TELEGRAM_BODY)) {
140-
m_logger.queue(LogLevel::Detail, "received", comm::ECHO_TELEGRAM_BODY);
98+
logger.queue(LogLevel::Detail, "received", comm::ECHO_TELEGRAM_BODY);
14199
is_echo_telegram = true;
142100
status = ActivityStatus::CLIENT_ACTIVITY;
143101
}
144102

145103
if (!is_echo_telegram) {
146-
m_logger.queue(LogLevel::Detail, "received composed", get_pretty_size_str_from_bytes_num(message.size()), ":", get_truncated_middle_str(message));
104+
logger.queue(LogLevel::Detail, "received composed", get_pretty_size_str_from_bytes_num(message.size()), ":", get_truncated_middle_str(message));
147105
std::optional<int> job_id_opt = comm::TelegramParser::try_extract_field_job_id(message);
148106
std::optional<int> cmd_opt = comm::TelegramParser::try_extract_field_cmd(message);
149107
std::optional<std::string> options_opt = comm::TelegramParser::try_extract_field_options(message);
150108
if (job_id_opt && cmd_opt && options_opt) {
151109
TaskPtr task = std::make_unique<Task>(job_id_opt.value(), static_cast<comm::CMD>(cmd_opt.value()), options_opt.value());
152110
const comm::TelegramHeader& header = telegram_frame->header;
153-
m_logger.queue(LogLevel::Info, "received:", header.info(), task->info(/*skipDuration*/ true));
154-
std::unique_lock<std::mutex> lock(m_tasks_mutex);
155-
m_received_tasks.push_back(std::move(task));
111+
logger.queue(LogLevel::Info, "received:", header.info(), task->info(/*skipDuration*/ true));
112+
std::unique_lock<std::mutex> lock(tasks_mutex);
113+
received_tasks.push_back(std::move(task));
156114
} else {
157-
m_logger.queue(LogLevel::Error, "broken telegram detected, fail extract options from", message);
115+
logger.queue(LogLevel::Error, "broken telegram detected, fail extract options from", message);
158116
}
159117
}
160118
}
161119

162120
return status;
163121
}
164122

165-
GateIO::ActivityStatus GateIO::handle_client_alive_tracker(sockpp::tcp6_socket& client, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr) {
123+
static ActivityStatus handle_client_alive_tracker(sockpp::tcp6_socket& client, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr, TLogger& logger) {
166124
ActivityStatus status = ActivityStatus::WAITING_ACTIVITY;
167125
if (client_alive_tracker_ptr) {
168126
/// handle sending echo to client
@@ -173,26 +131,26 @@ GateIO::ActivityStatus GateIO::handle_client_alive_tracker(sockpp::tcp6_socket&
173131
try {
174132
std::size_t bytes_sent = client.write(message);
175133
if (bytes_sent == message.size()) {
176-
m_logger.queue(LogLevel::Detail, "sent", comm::ECHO_TELEGRAM_BODY);
134+
logger.queue(LogLevel::Detail, "sent", comm::ECHO_TELEGRAM_BODY);
177135
client_alive_tracker_ptr->on_echo_sent();
178136
}
179137
} catch (...) {
180-
m_logger.queue(LogLevel::Debug, "fail to sent", comm::ECHO_TELEGRAM_BODY);
138+
logger.queue(LogLevel::Debug, "fail to sent", comm::ECHO_TELEGRAM_BODY);
181139
status = ActivityStatus::COMMUNICATION_PROBLEM;
182140
}
183141
}
184142

185143
/// handle client timeout
186144
if (client_alive_tracker_ptr->is_client_timeout()) {
187-
m_logger.queue(LogLevel::Error, "client didn't respond too long");
145+
logger.queue(LogLevel::Error, "client didn't respond too long");
188146
status = ActivityStatus::COMMUNICATION_PROBLEM;
189147
}
190148
}
191149

192150
return status;
193151
}
194152

195-
void GateIO::handle_activity_status(ActivityStatus status, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr, bool& is_communication_problem_detected) {
153+
static void handle_activity_status(ActivityStatus status, std::unique_ptr<ClientAliveTracker>& client_alive_tracker_ptr, bool& is_communication_problem_detected) {
196154
if (status == ActivityStatus::CLIENT_ACTIVITY) {
197155
if (client_alive_tracker_ptr) {
198156
client_alive_tracker_ptr->on_client_activity();
@@ -202,9 +160,54 @@ void GateIO::handle_activity_status(ActivityStatus status, std::unique_ptr<Clien
202160
}
203161
}
204162

163+
GateIO::GateIO() {
164+
m_is_running.store(false);
165+
}
166+
167+
GateIO::~GateIO() {
168+
stop();
169+
}
170+
171+
void GateIO::start(int port_num) {
172+
if (!m_is_running.load()) {
173+
m_port_num = port_num;
174+
VTR_LOG("starting server");
175+
m_is_running.store(true);
176+
m_thread = std::thread(&GateIO::start_listening, this);
177+
}
178+
}
179+
180+
void GateIO::stop() {
181+
if (m_is_running.load()) {
182+
m_is_running.store(false);
183+
if (m_thread.joinable()) {
184+
m_thread.join();
185+
}
186+
}
187+
}
188+
189+
void GateIO::take_received_tasks(std::vector<TaskPtr>& tasks) {
190+
std::unique_lock<std::mutex> lock(m_tasks_mutex);
191+
for (TaskPtr& task : m_received_tasks) {
192+
m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "for processing");
193+
tasks.push_back(std::move(task));
194+
}
195+
m_received_tasks.clear();
196+
}
197+
198+
void GateIO::move_tasks_to_send_queue(std::vector<TaskPtr>& tasks) {
199+
std::unique_lock<std::mutex> lock(m_tasks_mutex);
200+
for (TaskPtr& task : tasks) {
201+
m_logger.queue(LogLevel::Debug, "move task id=", task->job_id(), "finished", (task->has_error() ? "with error" : "successfully"), task->error(), "to send queue");
202+
m_send_tasks.push_back(std::move(task));
203+
}
204+
tasks.clear();
205+
}
206+
205207
void GateIO::start_listening() {
206208
#ifdef ENABLE_CLIENT_ALIVE_TRACKER
207-
std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr = std::make_unique<ClientAliveTracker>(std::chrono::milliseconds{5000}, std::chrono::milliseconds{20000});
209+
std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr =
210+
std::make_unique<ClientAliveTracker>(std::chrono::milliseconds{5000}, std::chrono::milliseconds{20000});
208211
#else
209212
std::unique_ptr<ClientAliveTracker> client_alive_tracker_ptr;
210213
#endif
@@ -232,7 +235,7 @@ void GateIO::start_listening() {
232235
bool is_communication_problem_detected = false;
233236

234237
if (!client_opt) {
235-
ActivityStatus status = check_client_connection(tcp_server, client_opt);
238+
ActivityStatus status = check_client_connection(tcp_server, client_opt, m_logger);
236239
if (status == ActivityStatus::CLIENT_ACTIVITY) {
237240
if (client_alive_tracker_ptr) {
238241
client_alive_tracker_ptr->reset();
@@ -244,15 +247,15 @@ void GateIO::start_listening() {
244247
sockpp::tcp6_socket& client = client_opt.value(); // shortcut
245248

246249
/// handle sending
247-
ActivityStatus status = handle_sending_data(client);
250+
ActivityStatus status = handle_sending_data(client, m_tasks_mutex, m_send_tasks, m_logger);
248251
handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
249252

250253
/// handle receiving
251-
status = handle_receiving_data(client, telegram_buff, received_message);
254+
status = handle_receiving_data(client, telegram_buff, received_message, m_logger);
252255
handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
253256

254257
/// handle telegrams
255-
status = handle_telegrams(telegram_frames, telegram_buff);
258+
status = handle_telegrams(telegram_frames, telegram_buff, m_tasks_mutex, m_received_tasks, m_logger);
256259
handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
257260

258261
// forward telegramBuffer errors
@@ -263,7 +266,7 @@ void GateIO::start_listening() {
263266
}
264267

265268
/// handle client alive tracker
266-
status = handle_client_alive_tracker(client, client_alive_tracker_ptr);
269+
status = handle_client_alive_tracker(client, client_alive_tracker_ptr, m_logger);
267270
handle_activity_status(status, client_alive_tracker_ptr, is_communication_problem_detected);
268271

269272
/// handle communication problem

0 commit comments

Comments
 (0)