ae/ECAP_Server
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

concurrencpp 换成asio协程

Browse Source
This commit is contained in:
种太阳的热带美短
2026-06-29 08:50:10 +08:00
parent c683038d3a
commit cd446b7ca8
11 changed files with 335 additions and 315 deletions
Download Patch File Download Diff File Expand all files Collapse all files
module/Local_Server/Data_Feed/Data_Feed.cpp
+6 -23
View File
@@ -1,6 +1,5 @@
#include "Local_Server/Data_Feed/Data_Feed.h"
#include "../server/Global.h"
bool Data_Feed::registered() {
auto all_feed = Global::instance()->mode_acs.data_feed_config.map.list();
for (auto& item : all_feed) {
@@ -10,24 +9,20 @@ bool Data_Feed::registered() {
}
return false;
}
concurrencpp::result<void> Data_Feed_UDP_Server::handle_in_loop_coro() {
asio::awaitable<void> Data_Feed_UDP_Server::handle_in_loop_coro() {
co_await svr.tick_coro();
co_return;
}
concurrencpp::result<void> Data_Feed_UDP_Server::send_coro(const std::string& data) {
asio::awaitable<void> Data_Feed_UDP_Server::send_coro(const std::string& data) {
co_await svr.write_to_all_clients_coro(data);
co_return;
}
concurrencpp::result<void> Data_Feed_UDP_Server::_open() {
asio::awaitable<void> Data_Feed_UDP_Server::_open() {
svr.set_bind_address("0.0.0.0", port);
svr.create();
server_logger->c_debug({}, {}, to_string() + "开启！");
co_return;
}
JSON Data_feed_Config::get_feed(const std::string& key) {
auto ret = map.get(key);
if (ret.has_value()) {
@@ -36,8 +31,7 @@ JSON Data_feed_Config::get_feed(const std::string& key) {
}
return {nullptr};
}
void Data_feed_Config::server(Global* g) {
void Data_feed_Config::server(Global *g) {
auto& svr = g->svr;
auto& api = g->api;
std::string name = "data_feed";
@@ -86,13 +80,10 @@ void Data_feed_Config::server(Global* g) {
svr.Post(api + svr.update + name, [g, this](HTTP_Param) {
CHECK_JSON_PARAM
HTTP_REQUIRE_VALUE(key, params.try_get_string("key"))
HTTP_REQUIRE_VALUE(t, map.get(key))
HTTP_REQUIRE_VALUE(df, map.get(key))
// 直接关闭
// t->close();
t->from_json(&params);
// if (t->enable) {
// t->check_and_open();
// }
df->from_json(&params);
Global::save();
g->mode_acs.source_feed_relation_config.set_need_refresh();
});
@@ -104,10 +95,6 @@ void Data_feed_Config::server(Global* g) {
auto df = create_data_feed_from_type(t);
df->from_json(data);
HTTP_REQUIRE_VALUE(enable, data->try_get_bool("enable"))
// if (enable)
// {
// df->check_and_open();
// }
HTTP_REQUIRE_TRUE(map.insert(index, df), "index")
res->setBody(warp(to_json()).to_json_string());
Global::save();
@@ -140,7 +127,6 @@ void Data_feed_Config::server(Global* g) {
g->mode_acs.source_feed_relation_config.set_need_refresh();
});
}
void BIN_Msg_Buffer::push(const std::string& msg) {
auto output_packet_size =
Global::instance()->mode_acs.data_feed_config.packet_byte_size.load();
@@ -156,7 +142,6 @@ void BIN_Msg_Buffer::push(const std::string& msg) {
msg_list_cache.back()->append(msg);
}
}
const std::vector<std::string*>& BIN_Msg_Buffer::get_all() {
std::lock_guard<std::mutex> g(mtx);
std::swap(msg_list_cache, msg_list);
@@ -165,12 +150,10 @@ const std::vector<std::string*>& BIN_Msg_Buffer::get_all() {
mode_other_msg_num = 0;
return msg_list;
}
BIN_Msg_Buffer::BIN_Msg_Buffer() {
msg_list_cache.reserve(8 * 1024);
msg_list.reserve(8 * 1024);
}
Psc::JSON BIN_Msg_Buffer::state_json() {
auto output_packet_size =
Global::instance()->mode_acs.data_feed_config.packet_byte_size.load();
module/Local_Server/Data_Feed/Data_Feed.h
+19 -19
View File
@@ -17,15 +17,15 @@ public:
BIN_Msg_Buffer msg_buffer{};
Output_Format output_format;
Frequency_Limit_Multi sbs_flm{};
concurrencpp::result<void> loop_coro() final;
asio::awaitable<void> loop_coro() final;
virtual void handle_in_loop() {}
virtual concurrencpp::result<void> handle_in_loop_coro() {
virtual asio::awaitable<void> handle_in_loop_coro() {
handle_in_loop();
co_return;
}
virtual concurrencpp::result<void> send_coro(const std::string&) {
virtual asio::awaitable<void> send_coro(const std::string&) {
co_return;
}
@@ -83,13 +83,13 @@ public:
~Data_Feed_TCP_Server() override = default;
concurrencpp::result<void> handle_in_loop_coro() override {
asio::awaitable<void> handle_in_loop_coro() override {
co_await svr.flush_clients_coro();
co_await svr.tick_coro();
co_return;
}
concurrencpp::result<void> send_coro(const std::string& data) override {
asio::awaitable<void> send_coro(const std::string& data) override {
co_await svr.write_to_all_clients_coro(data);
co_return;
}
@@ -105,12 +105,12 @@ public:
return ret;
}
concurrencpp::result<void> _close() override {
asio::awaitable<void> _close() override {
co_await svr.close_coro();
co_return;
}
concurrencpp::result<void> _open() override {
asio::awaitable<void> _open() override {
svr.set_connect_user_buffer_size(connect_user_buffer_size);
svr.set_connect_system_buffer_size(connect_system_buffer_size);
svr.set_tcp_no_delay(false);
@@ -157,12 +157,12 @@ public:
};
class Data_Feed_TCP_Client : public Data_Feed, public Data_Feed_TCP_Client_Data {
public:
concurrencpp::result<void> handle_in_loop_coro() override {
asio::awaitable<void> handle_in_loop_coro() override {
co_await cli.tick_coro();
co_return;
}
concurrencpp::result<void> send_coro(const std::string& data) override {
asio::awaitable<void> send_coro(const std::string& data) override {
co_await cli.send_coro(data);
co_return;
}
@@ -178,12 +178,12 @@ public:
Psc::asio_socket::TCP_Client_Coro cli;
~Data_Feed_TCP_Client() override = default;
concurrencpp::result<void> _close() override {
asio::awaitable<void> _close() override {
co_await cli.close_coro();
co_return;
}
concurrencpp::result<void> _open() override {
asio::awaitable<void> _open() override {
Psc::asio_socket::Sockaddr_In sockaddr_in;
sockaddr_in.ip = url;
sockaddr_in.port = port;
@@ -216,8 +216,8 @@ public:
Data_Feed_UDP_Server() = default;
~Data_Feed_UDP_Server() override = default;
concurrencpp::result<void> handle_in_loop_coro() override;
concurrencpp::result<void> send_coro(const std::string& data) override;
asio::awaitable<void> handle_in_loop_coro() override;
asio::awaitable<void> send_coro(const std::string& data) override;
[[nodiscard]] Psc::JSON get_clients_json() const {
Psc::JSON ret = Psc::JSON::array();
@@ -239,12 +239,12 @@ public:
return Data_Feed::to_json() += Data_Feed_UDP_Server_Data::to_base_json();
}
concurrencpp::result<void> _close() override {
asio::awaitable<void> _close() override {
co_await svr.close_coro();
co_return;
}
concurrencpp::result<void> _open() override;
asio::awaitable<void> _open() override;
Psc::asio_socket::UDP_Server_Coro svr;
};
class Data_Feed_UDP_Client_Data {
@@ -263,12 +263,12 @@ public:
return VAR_JSON_1(state);
}
concurrencpp::result<void> handle_in_loop_coro() override {
asio::awaitable<void> handle_in_loop_coro() override {
co_await cli.tick_coro();
co_return;
}
concurrencpp::result<void> send_coro(const std::string& data) override {
asio::awaitable<void> send_coro(const std::string& data) override {
co_await cli.send_coro(data);
co_return;
}
@@ -284,14 +284,14 @@ public:
return Data_Feed::to_json() += Data_Feed_UDP_Client_Data::to_base_json();
}
concurrencpp::result<void> _close() override {
asio::awaitable<void> _close() override {
std::cout << "udp client target address:" << cli.dest_address.to_string()
<< " closed" << std::endl;
co_await cli.close_coro();
co_return;
}
concurrencpp::result<void> _open() override {
asio::awaitable<void> _open() override {
cli.create();
cli.set_dest_address(url, port);
co_await cli.connect_coro();
module/Local_Server/Data_Source/Data_Source.cpp
+12 -44
View File
@@ -2,7 +2,6 @@
#include <codecvt>
#include "../server/Global.h"
#include "Database.h"
Psc::serial::Serial* create_serial(const std::string& serial_name,
Baud_Rate_Type baud_rate) {
auto serial = new Psc::serial::Serial;
@@ -25,8 +24,7 @@ Psc::serial::Serial* create_serial(const std::string& serial_name,
}
return serial;
}
std::shared_ptr<Data_Source> create_from_json(const JSON* that_json) {
std::shared_ptr<Data_Source> create_from_json(const JSON *that_json) {
std::string type = that_json->get_string("type");
std::shared_ptr<Data_Source> ret = create_data_source_from_type(type);
ret->from_json(that_json);
@@ -36,11 +34,9 @@ std::shared_ptr<Data_Source> create_from_json(const JSON* that_json) {
// }
return ret;
}
std::shared_ptr<Data_Source> Data_Source::that() {
return shared_from_this();
}
bool Data_Source::registered() const {
auto all_source = Global::instance()->mode_acs.data_source_config.map.list();
for (auto& item : all_source) {
@@ -50,7 +46,6 @@ bool Data_Source::registered() const {
}
return false;
}
Psc::JSON Data_Source::get_state() {
Psc::JSON ret = Psc::JSON::object();
ret.append_list(get_custom_state_json().children);
@@ -58,7 +53,6 @@ Psc::JSON Data_Source::get_state() {
ret.append({"ds: value_statistics（byte）", value_statistics});
return ret;
}
Data_Source::Data_Source() {
// parse_format = std::make_shared<Input_Format>();
// 写入到配置文件是懒加载 其他保存时他跟着保存
@@ -70,12 +64,10 @@ Data_Source::Data_Source() {
}
};
}
std::string Data_Source::thread_key() const {
// return "Data_Source_Handle_Thread:[" + key + "]";
return key + "_DS_HT";
}
void File_Data_Source::before_handle_msg(std::shared_ptr<SSR::Mode_Msg>& msg) {
auto cur = std::dynamic_pointer_cast<SSR::Mode_Msg>(msg);
if (cur != nullptr) {
@@ -90,7 +82,6 @@ void File_Data_Source::before_handle_msg(std::shared_ptr<SSR::Mode_Msg>& msg) {
}
}
}
std::vector<std::string> readLines(const std::string& path) {
std::vector<std::string> lines;
std::filesystem::path p =
@@ -146,7 +137,6 @@ std::vector<std::string> readLines(const std::string& path) {
std::cout << oss.str() << std::flush;
return lines;
}
std::string extractID(const std::string& logLine) {
size_t lastSpacePos = logLine.rfind(" "); // 查找最后一个空格
if (lastSpacePos != std::string::npos) {
@@ -154,7 +144,6 @@ std::string extractID(const std::string& logLine) {
}
return logLine;
}
time_t convert_to_timestamp(const std::string& str) {
// 创建一个结构体 tm 来存储解析后的时间
std::tm timeStruct = {};
@@ -172,7 +161,6 @@ time_t convert_to_timestamp(const std::string& str) {
}
return timestamp;
}
std::tuple<std::string, time_t> extractID2(const std::string& logLine) {
size_t lastSpacePos = logLine.rfind(" "); // 查找最后一个空格
time_t t = convert_to_timestamp(logLine.substr(0, 19));
@@ -184,15 +172,13 @@ std::tuple<std::string, time_t> extractID2(const std::string& logLine) {
}
return {logLine, t};
}
std::string bin_format(const std::string& hex, time_t t) {
std::tm* currentTime = std::localtime(&t);
std::tm *currentTime = std::localtime(&t);
auto sec = currentTime->tm_hour * 3600 + currentTime->tm_min * 60 +
currentTime->tm_sec;
SSR::MLAT_timestamp a(sec, 0);
return create_Binary_Format_memory(hex, 0, &a);
}
std::optional<std::string> File_Data_Source::get_raw_line(int& ret_index) {
if (index == 0 && part_infos.empty()) {
ret_index = -1;
@@ -220,9 +206,8 @@ std::optional<std::string> File_Data_Source::get_raw_line(int& ret_index) {
ret_index = index + 1;
return part_infos[index++];
}
// 1A 33 1A 1A F1 FB 87 73 7E 7F a8001d81a87543b0a80000
std::string get_true_from_raw_line(Data_Source* ds, File_Data_Type data_type,
std::string get_true_from_raw_line(Data_Source *ds, File_Data_Type data_type,
int index, const std::string& log_info) {
std::string ret;
// 2025-01-06 07:20:17 [info] dc2541e65001401a3119b2dd1c7af67132201
@@ -326,15 +311,13 @@ std::string get_true_from_raw_line(Data_Source* ds, File_Data_Type data_type,
}
return ret;
}
concurrencpp::result<void> File_Data_Source::_close() {
asio::awaitable<void> File_Data_Source::_close() {
std::lock_guard g(mtx);
index = 0;
part_infos.clear();
co_return;
}
concurrencpp::result<void> File_Data_Source::_open() {
asio::awaitable<void> File_Data_Source::_open() {
std::lock_guard g(mtx);
auto path = get_true_file_path();
namespace fs = std::filesystem;
@@ -351,7 +334,6 @@ concurrencpp::result<void> File_Data_Source::_open() {
state = "已加载" + to_string(part_infos.size()) + "长度数据!";
co_return;
}
std::vector<std::string> File_Data_Source::readBinaryFileAsString(const std::string& filepath,
size_t part_size) {
// 打开文件（以二进制模式）
@@ -385,7 +367,6 @@ std::vector<std::string> File_Data_Source::readBinaryFileAsString(const std::str
file.close();
return parts;
}
void File_Data_Source::origin_data_transform_mode_data(std::string& mode_data) {
std::lock_guard g(mtx);
assert(mode_data.size() == 0);
@@ -416,13 +397,10 @@ void File_Data_Source::origin_data_transform_mode_data(std::string& mode_data) {
mode_data = ret;
}
}
void File_Data_Source::handle_mode_s(std::shared_ptr<SSR::Mode_S_Msg> msg) {
if (!msg)
return;
if (!msg) return;
cache_list.push_back(std::make_shared<Cache_Msg>(std::move(msg)));
if (cache_list.empty())
return;
if (cache_list.empty()) return;
if (pre_cache == nullptr) {
pre_cache = cache_list.front();
cache_list.pop_front();
@@ -432,8 +410,7 @@ void File_Data_Source::handle_mode_s(std::shared_ptr<SSR::Mode_S_Msg> msg) {
}
auto sys_time = player_clock.get_cur_time_point();
while (true) {
if (cache_list.empty())
break;
if (cache_list.empty()) break;
auto pre = pre_cache;
auto cur = cache_list.front();
cur->day_num = pre->day_num;
@@ -448,11 +425,9 @@ void File_Data_Source::handle_mode_s(std::shared_ptr<SSR::Mode_S_Msg> msg) {
}
}
}
void Dll_Data_Source::origin_data_transform_mode_data(std::string& mode_data) {
auto start = std::chrono::steady_clock::now();
if (read_func_ptr == nullptr)
return;
if (read_func_ptr == nullptr) return;
auto buf = reinterpret_cast<char*>(buffer.data());
auto len = read_func_ptr(buf, buffer_size);
vs.update(len);
@@ -472,18 +447,15 @@ void Dll_Data_Source::origin_data_transform_mode_data(std::string& mode_data) {
// std::cout << "Dll_Data_Source::read cost: " << cost << " us\n";
mode_data = ret;
}
concurrencpp::result<void> Shared_Memory_Data_Source::_open() {
asio::awaitable<void> Shared_Memory_Data_Source::_open() {
sm = std::make_unique<Psc::SM_RingBuffer>();
sm->init(shared_memory_name, shared_memory_size);
co_return;
}
concurrencpp::result<void> Shared_Memory_Data_Source::_close() {
asio::awaitable<void> Shared_Memory_Data_Source::_close() {
sm.reset();
co_return;
}
void Shared_Memory_Data_Source::origin_data_transform_mode_data(
std::string& mode_data) {
auto size = sm->shm.size();
@@ -503,8 +475,7 @@ void Shared_Memory_Data_Source::origin_data_transform_mode_data(
auto ret = get_true_from_raw_line(this, data_type, -1, data);
mode_data = ret;
}
void Data_Source_Config::server(Global* g) {
void Data_Source_Config::server(Global *g) {
auto& svr = g->svr;
auto& api = g->api;
std::string name = "data_source";
@@ -536,9 +507,6 @@ void Data_Source_Config::server(Global* g) {
CHECK_JSON_PARAM
HTTP_REQUIRE_VALUE(key, params.try_get_string("key"))
HTTP_REQUIRE_VALUE(ds, map.get(key))
// 直接关闭
// ds->enable = false;
// ds->close();
ds->from_json(&params);
g->save();
g->mode_acs.source_feed_relation_config.set_need_refresh();
module/Local_Server/Data_Source/Data_Source.h
+17 -17
View File
@@ -73,15 +73,15 @@ class Data_Source : public std::enable_shared_from_this<Data_Source>,
public Data_Source_Handler, public Data_Source_Data {
public:
std::shared_ptr<Data_Source> that();
virtual concurrencpp::result<std::string> read_coro() {co_return "";}
virtual asio::awaitable<std::string> read_coro() {co_return "";}
bool registered() const;
virtual Psc::JSON get_custom_state_json() = 0;
Psc::JSON get_state();
std::string last_char; // 用于处理奇数字节
Data_Source();
concurrencpp::result<void> loop_coro() final;
asio::awaitable<void> loop_coro() final;
std::shared_ptr<SSR::Mode_Msg> last_prase_msg = nullptr;
virtual concurrencpp::result<void> handle_in_loop_coro() { co_return;}
virtual asio::awaitable<void> handle_in_loop_coro() { co_return;}
Frequency_Limit statistic_fl;
std::string thread_key() const;
Psc::JSON statistic_json() {
@@ -110,7 +110,7 @@ public:
};
class TCP_Client_Data_Source : public Data_Source, public TCP_Client_Data_Source_Data {
public:
concurrencpp::result<void> handle_in_loop_coro() override {
asio::awaitable<void> handle_in_loop_coro() override {
co_await cli.tick_coro();
co_return;
}
@@ -123,7 +123,7 @@ public:
TCP_Client_Data_Source() {
type = "TCP_Client_Data_Source";
}
concurrencpp::result<void> _open() override {
asio::awaitable<void> _open() override {
Psc::asio_socket::Sockaddr_In addr;
addr.ip = ip;
addr.port = port;
@@ -132,7 +132,7 @@ public:
co_await cli.connect_coro();
co_return;
}
concurrencpp::result<void> _close() override {
asio::awaitable<void> _close() override {
co_await cli.close_coro();
co_return;
}
@@ -143,7 +143,7 @@ public:
Data_Source::from_json(that_json);
TCP_Client_Data_Source_Data::from_base_json(that_json);
}
concurrencpp::result<std::string> read_coro() override {
asio::awaitable<std::string> read_coro() override {
co_return co_await cli.read_coro();
}
};
@@ -161,7 +161,7 @@ public:
Serial_Data_Source() {
this->type = "Serial_Data_Source";
}
concurrencpp::result<void> _open() override {
asio::awaitable<void> _open() override {
serial = std::make_unique<Psc::serial::Serial_Coro>();
serial->set_serial_name(port_name);
serial->set_baud_rate(baud_rate);
@@ -181,18 +181,18 @@ public:
}
co_return;
}
concurrencpp::result<void> _close() override {
asio::awaitable<void> _close() override {
if (serial)
serial->close();
co_return;
}
concurrencpp::result<void> handle_in_loop_coro() override {
asio::awaitable<void> handle_in_loop_coro() override {
if (serial) {
co_await serial->tick_coro();
}
co_return;
}
concurrencpp::result<std::string> read_coro() override {
asio::awaitable<std::string> read_coro() override {
if (!serial) {
co_return "";
}
@@ -261,8 +261,8 @@ public:
std::string get_true_file_path() const {
return Psc::get_abs_path(file_path);
}
concurrencpp::result<void> _close() override;
concurrencpp::result<void> _open() override;
asio::awaitable<void> _close() override;
asio::awaitable<void> _open() override;
std::vector<std::string> readBinaryFileAsString(const std::string& filepath,
size_t part_size);
void from_json(const Psc::JSON* that_json) override {
@@ -316,11 +316,11 @@ public:
using Call_Back = void (*)(char* buf, std::size_t len);
using set_Call_back = void (*)(Call_Back);
std::string state;
concurrencpp::result<void> _close() override {
asio::awaitable<void> _close() override {
Psc::free_library(lib);
co_return;
}
concurrencpp::result<void> _open() override {
asio::awaitable<void> _open() override {
{
auto r = Psc::try_load_library(Psc::get_abs_path(library_path));
if (!r) {
@@ -363,8 +363,8 @@ public:
Psc::JSON to_json() override {
return Data_Source::to_json() += Shared_Memory_Data_Source_Data::to_base_json();
}
concurrencpp::result<void> _open() override;
concurrencpp::result<void> _close() override;
asio::awaitable<void> _open() override;
asio::awaitable<void> _close() override;
void origin_data_transform_mode_data(std::string& data) override;
protected:
std::unique_ptr<Psc::SM_RingBuffer> sm;
module/Local_Server/External_Database/External_Database.cpp
+9 -9
View File
@@ -60,7 +60,7 @@ void run_external_database_async(Work &&work, Callback &&callback) {
}
template <typename T, typename Starter>
concurrencpp::result<T> await_external_database_callback(Starter starter) {
asio::awaitable<T> await_external_database_callback(Starter starter) {
auto result = co_await Psc::coro::callback_result<T>(
[starter = std::move(starter)](auto done) mutable {
starter([done = std::move(done)](std::exception_ptr exception,
@@ -417,7 +417,7 @@ void External_Resources_Manager::async_external_database_status(
[this]() { return external_database_status(); }, std::move(callback));
}
concurrencpp::result<std::vector<External_Resource_Status>>
asio::awaitable<std::vector<External_Resource_Status>>
External_Resources_Manager::refresh_external_databases_coro(
const bool force_download) {
co_return co_await await_external_database_callback<
@@ -427,7 +427,7 @@ External_Resources_Manager::refresh_external_databases_coro(
});
}
concurrencpp::result<External_Resource_Status>
asio::awaitable<External_Resource_Status>
External_Resources_Manager::refresh_external_database_coro(
std::string resource_name, const bool force_download) {
co_return co_await await_external_database_callback<External_Resource_Status>(
@@ -438,7 +438,7 @@ External_Resources_Manager::refresh_external_database_coro(
});
}
concurrencpp::result<External_Resource_Status>
asio::awaitable<External_Resource_Status>
External_Resources_Manager::import_external_database_coro(
std::string resource_name, std::filesystem::path source_file) {
co_return co_await await_external_database_callback<External_Resource_Status>(
@@ -450,7 +450,7 @@ External_Resources_Manager::import_external_database_coro(
});
}
concurrencpp::result<External_Resource_Status>
asio::awaitable<External_Resource_Status>
External_Resources_Manager::clear_external_database_table_coro(
std::string resource_name) {
co_return co_await await_external_database_callback<External_Resource_Status>(
@@ -461,7 +461,7 @@ External_Resources_Manager::clear_external_database_table_coro(
});
}
concurrencpp::result<std::optional<External_Database_Row>>
asio::awaitable<std::optional<External_Database_Row>>
External_Resources_Manager::query_external_database_coro(
std::string resource_name,
std::vector<std::string> primary_key_values) const {
@@ -476,7 +476,7 @@ External_Resources_Manager::query_external_database_coro(
});
}
concurrencpp::result<std::shared_ptr<External_Database_Row_Map>>
asio::awaitable<std::shared_ptr<External_Database_Row_Map>>
External_Resources_Manager::query_aircraft_external_databases_coro(
std::string icao24) const {
auto result = co_await Psc::coro::callback_result<
@@ -497,7 +497,7 @@ External_Resources_Manager::query_aircraft_external_databases_coro(
co_return result;
}
concurrencpp::result<std::shared_ptr<External_Database_Row_Map>>
asio::awaitable<std::shared_ptr<External_Database_Row_Map>>
External_Resources_Manager::query_callsign_external_databases_coro(
std::optional<std::string> callsign) const {
auto result = co_await Psc::coro::callback_result<
@@ -518,7 +518,7 @@ External_Resources_Manager::query_callsign_external_databases_coro(
co_return result;
}
concurrencpp::result<std::vector<External_Resource_Status>>
asio::awaitable<std::vector<External_Resource_Status>>
External_Resources_Manager::external_database_status_coro() const {
co_return co_await await_external_database_callback<
std::vector<External_Resource_Status>>(
module/Local_Server/External_Database/global.h
+9 -9
View File
@@ -1,7 +1,7 @@
#pragma once
#include "Core/Base/JSON.h"
#include <SQLiteCpp/Database.h>
#include <concurrencpp/concurrencpp.h>
#include <asio/awaitable.hpp>
#include <cstddef>
#include <cstdint>
#include <ctime>
@@ -103,14 +103,14 @@ public:
void async_query_aircraft_external_databases(std::string icao24, Row_Map_Callback callback) const;
void async_query_callsign_external_databases(std::optional<std::string> callsign, Row_Map_Callback callback) const;
void async_external_database_status(Status_List_Callback callback) const;
[[nodiscard]] concurrencpp::result<std::vector<External_Resource_Status>> refresh_external_databases_coro(bool force_download = true);
[[nodiscard]] concurrencpp::result<External_Resource_Status> refresh_external_database_coro(std::string resource_name, bool force_download = true);
[[nodiscard]] concurrencpp::result<External_Resource_Status> import_external_database_coro(std::string resource_name, std::filesystem::path source_file);
[[nodiscard]] concurrencpp::result<External_Resource_Status> clear_external_database_table_coro(std::string resource_name);
[[nodiscard]] concurrencpp::result<std::optional<External_Database_Row>> query_external_database_coro(std::string resource_name, std::vector<std::string> primary_key_values) const;
[[nodiscard]] concurrencpp::result<std::shared_ptr<External_Database_Row_Map>> query_aircraft_external_databases_coro(std::string icao24) const;
[[nodiscard]] concurrencpp::result<std::shared_ptr<External_Database_Row_Map>> query_callsign_external_databases_coro(std::optional<std::string> callsign) const;
[[nodiscard]] concurrencpp::result<std::vector<External_Resource_Status>> external_database_status_coro() const;
[[nodiscard]] asio::awaitable<std::vector<External_Resource_Status>> refresh_external_databases_coro(bool force_download = true);
[[nodiscard]] asio::awaitable<External_Resource_Status> refresh_external_database_coro(std::string resource_name, bool force_download = true);
[[nodiscard]] asio::awaitable<External_Resource_Status> import_external_database_coro(std::string resource_name, std::filesystem::path source_file);
[[nodiscard]] asio::awaitable<External_Resource_Status> clear_external_database_table_coro(std::string resource_name);
[[nodiscard]] asio::awaitable<std::optional<External_Database_Row>> query_external_database_coro(std::string resource_name, std::vector<std::string> primary_key_values) const;
[[nodiscard]] asio::awaitable<std::shared_ptr<External_Database_Row_Map>> query_aircraft_external_databases_coro(std::string icao24) const;
[[nodiscard]] asio::awaitable<std::shared_ptr<External_Database_Row_Map>> query_callsign_external_databases_coro(std::optional<std::string> callsign) const;
[[nodiscard]] asio::awaitable<std::vector<External_Resource_Status>> external_database_status_coro() const;
void register_external_resource(std::unique_ptr<External_Resources> external_res);
void initialize(SQLite::Database& db, std::filesystem::path cache_pos);
std::vector<External_Resource_Status> sync_missing(SQLite::Database& db);
module/Local_Server/server/Ucoro_Drogon_Glue.h
+94 -100
View File
@@ -1,5 +1,7 @@
#pragma once
#include <concurrencpp/concurrencpp.h>
#include <asio/awaitable.hpp>
#include <asio/co_spawn.hpp>
#include <asio/thread_pool.hpp>
#include <coroutine>
#include <drogon/drogon.h>
#include <exception>
@@ -7,113 +9,105 @@
#include <optional>
#include <trantor/net/EventLoop.h>
#include <utility>
namespace Ecap_Coro {
template <typename T> class Concurrencpp_Drogon_Awaiter {
inline asio::thread_pool& asio_drogon_pool() {
static asio::thread_pool pool(1);
return pool;
}
template <typename T> class Asio_Drogon_Awaiter {
public:
explicit Concurrencpp_Drogon_Awaiter(concurrencpp::result<T> &&task)
: state_(std::make_shared<State>()), task_(std::move(task)) {}
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> continuation) {
state_->continuation = continuation;
state_->loop = trantor::EventLoop::getEventLoopOfCurrentThread();
if (state_->loop == nullptr) {
state_->loop = drogon::app().getLoop();
}
state_->running_task.emplace(run(state_, std::move(task_)));
}
T await_resume() {
if (state_->exception) {
std::rethrow_exception(state_->exception);
}
return std::move(*state_->value);
}
explicit Asio_Drogon_Awaiter(asio::awaitable<T>&& task)
: state_(std::make_shared<State>()), task_(std::move(task)) {}
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> continuation) {
state_->continuation = continuation;
state_->loop = trantor::EventLoop::getEventLoopOfCurrentThread();
if (state_->loop == nullptr) {
state_->loop = drogon::app().getLoop();
}
asio::co_spawn(asio_drogon_pool(), std::move(task_),
[state = state_](std::exception_ptr exception, T value) mutable {
state->exception = exception;
if (!exception) {
state->value.emplace(std::move(value));
}
resume(std::move(state));
});
}
T await_resume() {
if (state_->exception) {
std::rethrow_exception(state_->exception);
}
return std::move(*state_->value);
}
private:
struct State {
trantor::EventLoop *loop{};
std::coroutine_handle<> continuation{};
std::optional<T> value{};
std::exception_ptr exception{};
std::optional<concurrencpp::result<void>> running_task{};
};
static concurrencpp::result<void> run(std::shared_ptr<State> state,
concurrencpp::result<T> task) {
try {
state->value.emplace(co_await task);
} catch (...) {
state->exception = std::current_exception();
}
resume(std::move(state));
co_return;
}
static void resume(std::shared_ptr<State> state) {
auto resume_fn = [state]() { state->continuation.resume(); };
if (state->loop != nullptr) {
state->loop->queueInLoop(std::move(resume_fn));
} else {
resume_fn();
}
}
std::shared_ptr<State> state_;
concurrencpp::result<T> task_;
struct State {
trantor::EventLoop* loop{};
std::coroutine_handle<> continuation{};
std::optional<T> value{};
std::exception_ptr exception{};
};
static void resume(std::shared_ptr<State> state) {
auto resume_fn = [state] { state->continuation.resume(); };
if (state->loop != nullptr) {
state->loop->queueInLoop(std::move(resume_fn));
}
else {
resume_fn();
}
}
std::shared_ptr<State> state_;
asio::awaitable<T> task_;
};
template <> class Concurrencpp_Drogon_Awaiter<void> {
template <> class Asio_Drogon_Awaiter<void> {
public:
explicit Concurrencpp_Drogon_Awaiter(concurrencpp::result<void> &&task)
: state_(std::make_shared<State>()), task_(std::move(task)) {}
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> continuation) {
state_->continuation = continuation;
state_->loop = trantor::EventLoop::getEventLoopOfCurrentThread();
if (state_->loop == nullptr) {
state_->loop = drogon::app().getLoop();
}
state_->running_task.emplace(run(state_, std::move(task_)));
}
void await_resume() {
if (state_->exception) {
std::rethrow_exception(state_->exception);
}
}
explicit Asio_Drogon_Awaiter(asio::awaitable<void>&& task)
: state_(std::make_shared<State>()), task_(std::move(task)) {}
bool await_ready() const noexcept { return false; }
void await_suspend(std::coroutine_handle<> continuation) {
state_->continuation = continuation;
state_->loop = trantor::EventLoop::getEventLoopOfCurrentThread();
if (state_->loop == nullptr) {
state_->loop = drogon::app().getLoop();
}
asio::co_spawn(asio_drogon_pool(), std::move(task_),
[state = state_](std::exception_ptr exception) mutable {
state->exception = exception;
resume(std::move(state));
});
}
void await_resume() {
if (state_->exception) {
std::rethrow_exception(state_->exception);
}
}
private:
struct State {
trantor::EventLoop *loop{};
std::coroutine_handle<> continuation{};
std::exception_ptr exception{};
std::optional<concurrencpp::result<void>> running_task{};
};
static concurrencpp::result<void> run(std::shared_ptr<State> state,
concurrencpp::result<void> task) {
try {
co_await task;
} catch (...) {
state->exception = std::current_exception();
}
resume(std::move(state));
co_return;
}
static void resume(std::shared_ptr<State> state) {
auto resume_fn = [state]() { state->continuation.resume(); };
if (state->loop != nullptr) {
state->loop->queueInLoop(std::move(resume_fn));
} else {
resume_fn();
}
}
std::shared_ptr<State> state_;
concurrencpp::result<void> task_;
struct State {
trantor::EventLoop* loop{};
std::coroutine_handle<> continuation{};
std::exception_ptr exception{};
};
static void resume(std::shared_ptr<State> state) {
auto resume_fn = [state] { state->continuation.resume(); };
if (state->loop != nullptr) {
state->loop->queueInLoop(std::move(resume_fn));
}
else {
resume_fn();
}
}
std::shared_ptr<State> state_;
asio::awaitable<void> task_;
};
template <typename T> auto to_drogon(concurrencpp::result<T> &&task) {
return Concurrencpp_Drogon_Awaiter<T>{std::move(task)};
template <typename T> auto to_drogon(asio::awaitable<T>&& task) {
return Asio_Drogon_Awaiter<T>{std::move(task)};
}
template <typename T>
drogon::Task<T> to_drogon_task(concurrencpp::result<T> &&task) {
co_return co_await to_drogon(std::move(task));
drogon::Task<T> to_drogon_task(asio::awaitable<T>&& task) {
co_return co_await to_drogon(std::move(task));
}
inline drogon::Task<> to_drogon_task(asio::awaitable<void>&& task) {
co_await to_drogon(std::move(task));
co_return;
}
inline drogon::Task<> to_drogon_task(concurrencpp::result<void> &&task) {
co_await to_drogon(std::move(task));
co_return;
}
} // namespace Ecap_Coro
module/Local_Server/server/With_Loop_Coro.cpp
+82 -29
View File
@@ -1,46 +1,99 @@
#include "With_Loop_Coro.h"
#include "io_coro.h"
With_Loop_Coro::~With_Loop_Coro() = default;
void With_Loop_Coro::async_stop() {
enable = false;
std::string name = type + ":" + key;
set_state(State::Force_Quit, std::format("任务正常收到请求,等待退出 {}!\n", name).c_str());
loop_running = false;
}
void With_Loop_Coro::sync_wait() const {
void With_Loop_Coro::sync_wait() {
std::string name = type + ":" + key;
if (!loop_task) {
std::cout << std::format("{}退出成功！ loop_task 未启动 \n", name);
return;
}
auto last = std::chrono::steady_clock::now();
while (loop_task->status() == concurrencpp::result_status::idle) {
auto now = std::chrono::steady_clock::now();
if (now - last > std::chrono::seconds(1)) {
std::cout << std::format("等待任务退出 {}:{}\n", type, key);
last = now;
}
std::this_thread::sleep_for(std::chrono::milliseconds(10));
while (loop_task->wait_for(std::chrono::milliseconds(0)) != std::future_status::ready) {
std::cout << std::format("{}等待退出 当前状态为{} \n", name, Psc::to_string(this->state));
std::this_thread::sleep_for(std::chrono::milliseconds(1000));
}
std::cout << std::format("{}退出成功！ \n", name);
}
bool With_Loop_Coro::running() const {
if (!loop_task) {
return false;
}
return loop_task->status() == concurrencpp::result_status::idle;
return loop_running;
}
concurrencpp::result<void> With_Loop_Coro::sync_coro_loop_and_enable() {
void With_Loop_Coro::set_state(State state, std::string action) {
if (!action.empty()) {
std::string name = type + "_" + key;
std::cout << std::format("{} {} {} ==> {} \n", name, action, Psc::to_string(this->state), Psc::to_string(state));
}
this->state = state;
}
With_Loop_Coro::With_Loop_Coro() : stop(0.1) {}
asio::awaitable<void> With_Loop_Coro::run_loop_coro() {
loop_running.store(true, std::memory_order_release);
try {
co_await loop_coro();
loop_running.store(false, std::memory_order_release);
co_return;
}
catch (...) {
loop_running.store(false, std::memory_order_release);
throw;
}
}
asio::awaitable<void> With_Loop_Coro::tick() {
std::string name = type + ":" + key;
if (loop_task && !running()) {
loop_task.reset();
co_await _close();
if (state == State::Force_Quit) {
std::cout << std::format("{} 正在强制退出!\n", name);
}
if (enable && !loop_task) {
co_await _open();
loop_task = std::make_shared<concurrencpp::result<void>>(loop_coro());
std::cout << std::format("启动任务 {}!\n", name);
if (state == State::Start) {
if (enable) {
set_state(State::Before_Request_Start_Loop);
}
}
else if (!enable && running()) {
std::cout << std::format("请求停止任务 {}!\n", name);
force_close();
else if (state == State::Before_Request_Start_Loop) {
co_await this->_open();
loop_running = enable;
loop_task = Coro::instance()->spawn(run_loop_coro());
set_state(State::Waiting_Loop_Start, "开始启动任务");
}
else if (state == State::Waiting_Loop_Start) {
if (running()) {
set_state(State::Loop_Running, "启动任务成功！");
}
}
else if (state == State::Loop_Running) {
if (enable && !running()) {
std::cout << std::format("任务未知原因已经退出 {}!\n", name);
try {
loop_task->get();
}
catch (const std::exception& e) {
std::cout << std::format("任务异常退出 {}! {}\n", name, e.what());
loop_running = false;
}
catch (...) {
std::cout << std::format("任务未知异常退出 {}!\n", name);
loop_running = false;
}
loop_task.reset();
co_await _close();
co_return;
}
if (!enable) {
set_state(State::Before_Request_Stop_Loop, std::format("{} 检测到 enable变化 异步退出开始！", name).c_str());
}
}
else if (state == State::Before_Request_Stop_Loop) {
loop_running = false;
set_state(State::Waiting_Stop_Loop, "退出变量已设置 等待退出");
}
else if (state == State::Waiting_Stop_Loop) {
if (!running()) {
loop_task.reset();
co_await this->_close();
set_state(State::Start, "任务正常退出");
}
}
co_return;
}
module/Local_Server/server/With_Loop_Coro.h
+25 -15
View File
@@ -1,9 +1,10 @@
#pragma once
#include <atomic>
#include <asio/awaitable.hpp>
#include <chrono>
#include <concurrencpp/concurrencpp.h>
#include <exception>
#include <format>
#include <future>
#include <iostream>
#include <memory>
#include <sstream>
@@ -11,29 +12,38 @@
#include <utility>
#include <vector>
#include "Core/Base/JSON.h"
#include "Core/Statistics/Frequency_Limit.h"
class With_Loop_Coro_Data {
public:
std::string type;
std::string key;
Psc::Copyable_Atomic<bool> enable{};
std::string type;
PSC_USE_JSON
};
class With_Loop_Coro : public With_Loop_Coro_Data {
public:
virtual ~With_Loop_Coro();
std::shared_ptr<concurrencpp::result<void>> loop_task;
virtual concurrencpp::result<void> loop_coro() = 0;
std::shared_ptr<std::future<void>> loop_task;
virtual asio::awaitable<void> loop_coro() = 0;
void async_stop();
void sync_wait() const;
void sync_wait();
bool running() const;
virtual void force_close() {}
concurrencpp::result<void> sync_coro_loop_and_enable();
virtual concurrencpp::result<void> _open() {
co_return;
}
virtual concurrencpp::result<void> _close() {
co_return;
}
asio::awaitable<void> tick();
virtual asio::awaitable<void> _open() = 0;
virtual asio::awaitable<void> _close() = 0;
enum class State {
Force_Quit,
Start,
Before_Request_Start_Loop,
Waiting_Loop_Start,
Loop_Running,
Before_Request_Stop_Loop,
Waiting_Stop_Loop
} state = State::Start;
void set_state(State state, std::string action = "");
With_Loop_Coro();
protected:
Psc::Copyable_Atomic<bool> loop_running{};
asio::awaitable<void> run_loop_coro();
Frequency_Limit_Multi stop;
};
module/Local_Server/server/io_coro.cpp
+41 -42
View File
@@ -4,11 +4,16 @@
#include "Core/Statistics/Frequency_Limit.h"
#include "Local_Server/Data_Feed/Data_Feed.h"
#include "Local_Server/Data_Source/Data_Source.h"
#include <asio/detached.hpp>
#include <asio/post.hpp>
#include <asio/steady_timer.hpp>
#include <asio/this_coro.hpp>
#include <asio/use_awaitable.hpp>
#include <chrono>
#include <exception>
#include <format>
#include <sstream>
#include <thread>
#include <exception>
static std::string thread_id_str() {
std::ostringstream oss;
oss << std::this_thread::get_id();
@@ -39,43 +44,30 @@ bool Coro::has_running_loop_tasks() {
void Coro::start() {
std::cout << "start_io_coro" << std::endl;
running.store(true, std::memory_order_release);
io = runtime_.make_executor<concurrencpp::worker_thread_executor>(
[](std::string_view thread_name) {
std::cout << std::format("协程io:{} 协程启动！\n", thread_name);
},
[](std::string_view thread_name) {
std::cout << std::format("协程io:{} 销毁！\n", thread_name);
});
// process_data = runtime_.make_executor<concurrencpp::worker_thread_executor>(
// [](std::string_view thread_name) {
// std::cout << std::format("process_data 协程:{} 协程启动！\n", thread_name);
// },
// [](std::string_view thread_name) {
// std::cout << std::format("process_data 协程:{} 销毁！\n", thread_name);
// });
auto n = std::thread::hardware_concurrency();
auto other_need = std::max<size_t>(2, std::thread::hardware_concurrency() / 2);
io.restart();
io_work = std::make_unique<asio::executor_work_guard<asio::io_context::executor_type>>(io.get_executor());
io_thread = std::thread([this] {
std::cout << std::format("协程io:{} 协程启动！\n", thread_id_str());
io.run();
std::cout << std::format("协程io:{} 销毁！\n", thread_id_str());
});
auto n = std::max<unsigned int>(1, std::thread::hardware_concurrency());
auto other_need = std::max<unsigned int>(2, n / 2);
if (n > other_need) {
n -= other_need;
}
else {
n = n / 2;
}
process_data = runtime_.make_executor<concurrencpp::thread_pool_executor>(
"process_data",
n,
std::chrono::seconds(5),
[](std::string_view thread_name) {
std::cout << std::format("多线程协程{} 启动！\n", thread_name);
},
[](std::string_view thread_name) {
std::cout << std::format("多线程协程{} 销毁！\n", thread_name);
});
std::cout << std::format("协程已经启动 process_data concurrency: 在n个线程上{}\n", process_data->max_concurrency_level());
data_feed_thread_task = std::make_unique<concurrencpp::result<void>>(coro_thread());
n = std::max<unsigned int>(1, n);
process_data = std::make_unique<asio::thread_pool>(n);
std::cout << std::format("协程已经启动 process_data concurrency: 在n个线程上{}\n", n);
data_feed_thread_task = std::make_unique<std::future<void>>(asio::co_spawn(io, coro_thread(), asio::use_future));
}
concurrencpp::result<void> Coro::sleep_for(std::chrono::milliseconds ms) {
co_await runtime_.timer_queue()->make_delay_object(ms, io);
asio::awaitable<void> Coro::sleep_for(std::chrono::milliseconds ms) {
auto executor = co_await asio::this_coro::executor;
asio::steady_timer timer(executor, ms);
co_await timer.async_wait(asio::use_awaitable);
co_return;
}
void Coro::stop() {
@@ -93,6 +85,7 @@ void Coro::stop() {
}
// 停止状态更新状态机
running = false;
asio::post(io, [] {});
if (data_feed_thread_task) {
std::cout << "等待 coro_thread 退出" << std::endl;
data_feed_thread_task->get();
@@ -103,12 +96,18 @@ void Coro::stop() {
for (auto& li : list) {
li->loop_task.reset();
}
process_data.reset();
io.reset();
if (process_data) {
process_data->join();
process_data.reset();
}
io_work.reset();
io.stop();
if (io_thread.joinable()) {
io_thread.join();
}
std::cout << "stop_io_coro end" << std::endl;
}
concurrencpp::result<void> Coro::coro_thread() {
co_await concurrencpp::resume_on(io);
asio::awaitable<void> Coro::coro_thread() {
while (running.load(std::memory_order_acquire)) {
auto list = get_all();
for (auto& li : list) {
@@ -119,10 +118,10 @@ concurrencpp::result<void> Coro::coro_thread() {
co_return;
}
bool data_feed_debug = false;
concurrencpp::result<void> Data_Feed::loop_coro() {
asio::awaitable<void> Data_Feed::loop_coro() {
auto feed = this;
auto co = Coro::instance();
co_await concurrencpp::resume_on(co->io);
co_await asio::post(co->io, asio::use_awaitable);
auto& mode_acs = Global::instance()->mode_acs;
auto& cfg = mode_acs.data_feed_config;
auto& pool = cfg.pool_;
@@ -178,16 +177,16 @@ concurrencpp::result<void> Data_Feed::loop_coro() {
std::cout << std::format("{} after send {}\n", key, thread_id_str());
}
}
co_await concurrencpp::resume_on(co->io);
co_await asio::post(co->io, asio::use_awaitable);
}
std::cout << std::format("{} feed loop exit {}\n", key, thread_id_str());
co_return;
}
bool data_source_debug = false;
concurrencpp::result<void> Data_Source::loop_coro() {
asio::awaitable<void> Data_Source::loop_coro() {
auto source = this;
auto co = Coro::instance();
co_await concurrencpp::resume_on(co->io);
co_await asio::post(co->io, asio::use_awaitable);
while (source->running()) {
if (data_source_debug) {
std::cout << std::format("{} source loop begin {}\n", key, thread_id_str());
@@ -209,7 +208,7 @@ concurrencpp::result<void> Data_Source::loop_coro() {
if (!enable || !source->running() || !source->registered()) {
break;
}
co_await concurrencpp::resume_on(co->process_data);
co_await asio::post(*co->process_data, asio::use_awaitable);
if (data_source_debug) {
std::cout << std::format("{} before process {}\n", key, thread_id_str());
}
@@ -232,7 +231,7 @@ concurrencpp::result<void> Data_Source::loop_coro() {
std::cout << std::format("{} 解析到数据 {} {}\n", name, num, thread_id_str());
}
}
co_await concurrencpp::resume_on(co->io);
co_await asio::post(co->io, asio::use_awaitable);
}
std::cout << std::format("{} source loop exit {}\n", key, thread_id_str());
co_return;
module/Local_Server/server/io_coro.h
+21 -8
View File
@@ -1,21 +1,34 @@
#pragma once
#pragma once
#include <asio/awaitable.hpp>
#include <asio/co_spawn.hpp>
#include <asio/executor_work_guard.hpp>
#include <asio/io_context.hpp>
#include <asio/thread_pool.hpp>
#include <asio/use_future.hpp>
#include <atomic>
#include <chrono>
#include <concurrencpp/concurrencpp.h>
#include <future>
#include <iostream>
#include <memory>
#include <thread>
#include "psc_global_include/Singleton.hpp"
class Coro : public Psc::Singleton<Coro> {
public:
void start();
void stop();
concurrencpp::result<void> sleep_for(std::chrono::milliseconds ms);
std::shared_ptr<concurrencpp::thread_pool_executor> process_data;
std::shared_ptr<concurrencpp::worker_thread_executor> io;
asio::awaitable<void> sleep_for(std::chrono::milliseconds ms);
asio::io_context io;
std::unique_ptr<asio::thread_pool> process_data;
template <typename Awaitable>
std::shared_ptr<std::future<void>> spawn(Awaitable&& awaitable) {
auto future = asio::co_spawn(io, std::forward<Awaitable>(awaitable), asio::use_future);
return std::make_shared<std::future<void>>(std::move(future));
}
private:
concurrencpp::result<void> coro_thread();
asio::awaitable<void> coro_thread();
bool has_running_loop_tasks();
concurrencpp::runtime runtime_;
std::unique_ptr<concurrencpp::result<void>> data_feed_thread_task;
std::unique_ptr<asio::executor_work_guard<asio::io_context::executor_type>> io_work;
std::thread io_thread;
std::unique_ptr<std::future<void>> data_feed_thread_task;
std::atomic<bool> running = false;
};