From aaf55ba65bf16c29777fcad2ffb4e7c86b917898 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Mon, 6 Nov 2023 11:17:27 -0500 Subject: [PATCH] check pt: Before going to chicago --- .../bts-cme-websocket-listener/main.cpp | 19 +- src/lib_bts-cme-websocket/CMakeLists.txt | 11 + .../bts-cme-websocket/cme_message_handler.h | 16 ++ .../cme_message_handler_proxy.h | 51 +++++ .../bts-cme-websocket/cme_message_logger.h | 19 ++ .../bts-cme-websocket/cme_subscription_id.h | 10 + .../cme_subscription_topic.h | 73 +++++++ .../cme_websocket_session.cpp | 205 ++++++++++++++++++ .../bts-cme-websocket/cme_websocket_session.h | 58 +++++ .../cme_websocket_session_config.h | 61 ++++++ .../messages/cme_book_level.h | 33 +++ .../messages/cme_instrument.h | 90 ++++++++ .../messages/cme_instrument_metadata.h | 33 +++ .../bts-cme-websocket/messages/cme_message.h | 35 +++ .../messages/cme_message_header.h | 53 +++++ .../messages/cme_product_key.h | 28 +++ .../messages/cme_trade_summary.h | 28 +++ .../messages/cme_trade_summary_payload.h | 19 ++ .../messages/cme_websocket_request.h | 10 + .../messages/cme_websocket_request_factory.h | 63 ++++++ .../messages/cme_websocket_request_payload.h | 18 ++ .../messages/private_order_qty.h | 17 ++ .../bts-cme-websocket/messages/top_of_book.h | 22 ++ .../ssl_certificate_verifier.cpp | 120 ++++++++++ .../ssl_certificate_verifier.h | 23 ++ .../bts-cme-websocket/tls_initializer.cpp | 42 ++++ .../bts-cme-websocket/tls_initializer.h | 15 ++ src/lib_bts-system/bts-system/HASH_IMPL.h | 15 ++ src/lib_bts-system/bts-system/HashCombiner.h | 27 +++ 29 files changed, 1211 insertions(+), 3 deletions(-) create mode 100644 src/lib_bts-cme-websocket/CMakeLists.txt create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler_proxy.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_logger.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_id.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_topic.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.cpp create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session_config.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_book_level.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument_metadata.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message_header.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_product_key.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary_payload.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_factory.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_payload.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/private_order_qty.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/messages/top_of_book.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.cpp create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.h create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.cpp create mode 100644 src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.h create mode 100644 src/lib_bts-system/bts-system/HASH_IMPL.h create mode 100644 src/lib_bts-system/bts-system/HashCombiner.h diff --git a/src/app_bts-cme-websocket-listener/bts-cme-websocket-listener/main.cpp b/src/app_bts-cme-websocket-listener/bts-cme-websocket-listener/main.cpp index c356f3f1c..bcdd1a88c 100644 --- a/src/app_bts-cme-websocket-listener/bts-cme-websocket-listener/main.cpp +++ b/src/app_bts-cme-websocket-listener/bts-cme-websocket-listener/main.cpp @@ -1,9 +1,11 @@ #include "bts-cme-websocket/cme_message_handler.h" +#include "bts-cme-websocket/cme_message_handler_proxy.h" #include "bts-cme-websocket/cme_message_logger.h" #include "bts-cme-websocket/cme_subscription_topic.h" #include "bts-cme-websocket/cme_websocket_session.h" #include "bts-cme-websocket/cme_websocket_session_config.h" #include "bts-cme-websocket/messages/cme_product_key.h" +#include "bts-cme-websocket/messages/cme_trade_summary_payload.h" #include "bts-system/UNUSED.h" #include "bts-system/json/json_dumper.h" #include "bts-system/json/json_reader.h" @@ -20,7 +22,12 @@ #include #include +using bts::system::json::JsonDumper; using bts::system::json::JsonReader; +using bts::websocket::CmeMessageHandlerProxy; +using bts::websocket::CmeMessageLogger; +using bts::websocket::CmeTradeSummaryPayload; +using bts::websocket::CmeWebsocketSession; using bts::websocket::CmeWebsocketSessionConfig; using CLI::App; using std::ifstream; @@ -36,6 +43,10 @@ static CmeWebsocketSessionConfig parse_config(const string &config_arg) { return cfg; } +static void on_trades(CmeTradeSummaryPayload payload) { + LOG(Md, Info, "on_trades.\n{}", JsonDumper::dump(payload)); +} + static void run(const std::string &config_arg) { const auto cfg = parse_config(config_arg); @@ -44,14 +55,16 @@ static void run(const std::string &config_arg) { ~CurlInit() { curlpp::terminate(); } } _CURL_INIT; - bts::websocket::CmeMessageLogger cme_handler; - bts::websocket::CmeWebsocketSession session{cfg}; + CmeMessageHandlerProxy trade_handler; + trade_handler.callback().bind<&on_trades>(); + // CmeMessageLogger cme_handler; + CmeWebsocketSession session{cfg}; session.start(); session.subscribe( std::vector{{"XCME", "FUT", "BTC"}}, std::vector{ bts::websocket::CmeSubscriptionTopic::TRADE_TICKER}, - &cme_handler); + &trade_handler); static const int sleep_secs = 3; while (true) { std::this_thread::sleep_for(std::chrono::seconds(sleep_secs)); diff --git a/src/lib_bts-cme-websocket/CMakeLists.txt b/src/lib_bts-cme-websocket/CMakeLists.txt new file mode 100644 index 000000000..1c55c6de6 --- /dev/null +++ b/src/lib_bts-cme-websocket/CMakeLists.txt @@ -0,0 +1,11 @@ +cmake_minimum_required(VERSION 3.23) +project(bts-cme-websocket) + +file( + GLOB_RECURSE ${PROJECT_NAME}_Sources + RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} + ${PROJECT_NAME}/*.cpp) +add_library(${PROJECT_NAME} ${${PROJECT_NAME}_Sources}) +target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}) +target_link_libraries(${PROJECT_NAME} PUBLIC bts-system bts-http bts-websocket) + diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler.h b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler.h new file mode 100644 index 000000000..33bb45962 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler.h @@ -0,0 +1,16 @@ +#pragma once + +#include "bts-cme-websocket/messages/cme_message.h" +#include "bts-system/delegate.h" + +#include + +namespace bts::websocket { + +class CmeMessageHandler { + public: + virtual ~CmeMessageHandler() = default; + virtual void on_message(const CmeMessage &msg) = 0; +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler_proxy.h b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler_proxy.h new file mode 100644 index 000000000..d15d9b569 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_handler_proxy.h @@ -0,0 +1,51 @@ +#pragma once + +#include "bts-cme-websocket/cme_message_handler.h" +#include "bts-cme-websocket/messages/cme_message.h" +#include "bts-system/delegate.h" + +#include + +namespace bts::websocket { + +/** + * CmeMessageHandler that provides a bindable callback to handle payloads + * (parsed from json to \tparam T). + */ +template +class CmeMessageHandlerProxy : public CmeMessageHandler { + public: + using Callback = system::Delegate; + + constexpr Callback &callback(); + + void on_message(const CmeMessage &msg) override; + + private: + Callback callback_; +}; + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +template +constexpr typename CmeMessageHandlerProxy::Callback & +CmeMessageHandlerProxy::callback() { + return callback_; +} + +template <> +inline void CmeMessageHandlerProxy::on_message( + const CmeMessage &msg) { + callback_(msg); +} + +template +inline void CmeMessageHandlerProxy::on_message(const CmeMessage &msg) { + if (msg.payload) { + callback_(msg.payload->get()); + } +} + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_logger.h b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_logger.h new file mode 100644 index 000000000..bbc55c995 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_message_logger.h @@ -0,0 +1,19 @@ +#pragma once + +#include "bts-cme-websocket/cme_message_handler.h" +#include "bts-cme-websocket/messages/cme_message.h" +#include "bts-system/json/json_dumper.h" + +#include +#include + +namespace bts::websocket { + +struct CmeMessageLogger : public bts::websocket::CmeMessageHandler { + void on_message(const CmeMessage &msg) override { + LOG(Md, Info, "CmeMessageLogger::on_message.\n{}", + bts::system::json::JsonDumper::dump(msg)); + } +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_id.h b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_id.h new file mode 100644 index 000000000..e7d79df5c --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_id.h @@ -0,0 +1,10 @@ +#pragma once + +#include "bts-system/value_wrapper.h" + +namespace bts::websocket { + +using CmeSubscriptionId = + system::ValueWrapper; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_topic.h b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_topic.h new file mode 100644 index 000000000..b0f1413d3 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_subscription_topic.h @@ -0,0 +1,73 @@ +#pragma once + +#include "bts-system/FMT_IMPL.h" +#include "bts-system/HASH_IMPL.h" +#include "bts-system/enum_macros.h" + +#include + +namespace bts::websocket { + +// clang-format off +#define FOR_ALL_VALUES(per_value) \ + per_value(CmeSubscriptionTopic, NONE) \ + per_value(CmeSubscriptionTopic, TRADE_TICKER) \ + per_value(CmeSubscriptionTopic, TOP_OF_BOOK) \ + per_value(CmeSubscriptionTopic, STAT) +// clang-format on + +/** + * Represents subscription topics (message types) at Cme. The names aren't + * verbatim matches with the subscriptionMessageType fields they represent in + * the websocket request json. See CmeWebsocketRequestFactory for details. + */ +ENUM_CLASS_DEF(CmeSubscriptionTopic, FOR_ALL_VALUES) + +inline std::string topic_outgoing_name(CmeSubscriptionTopic topic) { + switch (topic.value) { + case CmeSubscriptionTopic::NONE: + return {}; + case CmeSubscriptionTopic::TRADE_TICKER: + return "TRD"; + case CmeSubscriptionTopic::TOP_OF_BOOK: + return "TOB"; + default: + return topic.name(); + } +} + +inline std::string topic_incoming_name(CmeSubscriptionTopic topic) { + switch (topic.value) { + case CmeSubscriptionTopic::NONE: + return {}; + case CmeSubscriptionTopic::TRADE_TICKER: + return "TS"; + case CmeSubscriptionTopic::TOP_OF_BOOK: + return "OBTS"; + default: + return topic.name(); + } +} + +#undef FOR_ALL_VALUES + +inline void to_json(nlohmann::json &j, const CmeSubscriptionTopic &t) { + j = t.name(); +} + +inline void from_json(const nlohmann::json &j, CmeSubscriptionTopic &t) { + if (!CmeSubscriptionTopic::parse(j.get(), &t)) { + throw std::runtime_error{fmt::format( + "Failed to parse CmeSubscriptionTopic from '{}'", j.dump())}; + } +} + +} // namespace bts::websocket + +FMT_IMPL(bts::websocket::CmeSubscriptionTopic, t, "{}", t.name()); + +#define FOR_HASH_MEMBERS(op) op(value) + +HASH_IMPL(bts::websocket::CmeSubscriptionTopic, FOR_HASH_MEMBERS); + +#undef FOR_HASH_MEMBERS diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.cpp b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.cpp new file mode 100644 index 000000000..483369813 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.cpp @@ -0,0 +1,205 @@ +#include "cme_websocket_session.h" +#include "bts-cme-websocket/cme_message_handler.h" +#include "bts-cme-websocket/cme_subscription_id.h" +#include "bts-cme-websocket/cme_subscription_topic.h" +#include "bts-cme-websocket/cme_websocket_session_config.h" +#include "bts-cme-websocket/messages/cme_message.h" +#include "bts-cme-websocket/messages/cme_message_header.h" +#include "bts-cme-websocket/messages/cme_product_key.h" +#include "bts-cme-websocket/messages/cme_trade_summary.h" +#include "bts-cme-websocket/messages/cme_trade_summary_payload.h" +#include "bts-cme-websocket/messages/cme_websocket_request.h" +#include "bts-cme-websocket/messages/cme_websocket_request_factory.h" +#include "bts-cme-websocket/messages/top_of_book.h" +#include "bts-cme-websocket/ssl_certificate_verifier.h" +#include "bts-cme-websocket/tls_initializer.h" +#include "bts-http/http_client.h" +#include "bts-http/http_request.h" +#include "bts-http/http_response.h" +#include "bts-http/oauth_request.h" +#include "bts-http/oauth_requestor.h" +#include "bts-http/oauth_response.h" +#include "bts-system/TimeSpan.h" +#include "bts-system/TimeStamp.h" +#include "bts-system/UNUSED.h" +#include "bts-system/bts_assert.h" +#include "bts-system/json/json_dumper.h" +#include "bts-system/json/json_reader.h" +#include "bts-system/overloaded.h" +#include "bts-websocket/websocket_client.h" + +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace bts::websocket { + +using namespace std::chrono_literals; + +using nlohmann::json; +using std::optional; +using std::pair; +using std::shared_ptr; +using std::string; +using std::unordered_map; +using std::vector; +using system::json::JsonDumper; + +using SslContext = boost::asio::ssl::context; + +// ws endpoint http://markets.api.uat.cmegroup.com/marketdatastream/v1 + +#define _ASSERT_MSGF(condition, ...) \ + bts_assert_msgf(condition, "CmeWebsocketSession::" __VA_ARGS__) +#define _LOG(level, ...) LOG(md, level, "CmeWebsocketSession::" __VA_ARGS__) +#define _DIAG(...) _LOG(Diag, __VA_ARGS__) +#define _INFO(...) _LOG(Info, __VA_ARGS__) +#define _WARN(...) _LOG(Warn, __VA_ARGS__) +#define _ERROR(...) _LOG(Error, __VA_ARGS__) + +struct CmeWebsocketSession::PImpl { + PImpl(const CmeWebsocketSessionConfig &cfg) + : cfg(cfg), client(cfg.websocket) {} + + CmeWebsocketSessionConfig cfg; + WebsocketClient client; + CmeSubscriptionId sub_id_counter{0}; + string server_name; + std::optional run_thread; + int session_id{session_id_counter_++}; + CmeWebsocketRequestFactory req_factory_; + std::unordered_map>> + topic_handlers; + + ~PImpl() { + if (run_thread) { + run_thread->join(); + } + } + + void on_login_status(const CmeMessage &msg) { + _INFO("on_login_status:\n{}", JsonDumper::dump(msg)); + if (msg.payload->at("status").get() != "authenticated") { + _ERROR( + "on_login_status. status not authenticated:\n{}", + JsonDumper::dump(msg)); + return; + } + } + + void on_subscription_status(const CmeMessage &msg) { + // If there is an error, log it and return. + _INFO("on_subscription_status:\n{}", JsonDumper::dump(msg)); + if (msg.payload->at("status").get() != "subscribed") { + _ERROR( + "on_subscription_status. status not subscribed:\n{}", + JsonDumper::dump(msg)); + } + } + + void on_heartbeat(const CmeMessage & /*msg*/) { + // Placeholder for hearbeat handler + } + + void on_message(const string &msg_str) { + _INFO("on_message\n{}", msg_str); + CmeMessage msg; + try { + nlohmann::json::parse(msg_str).get_to(msg); + } catch (const std::exception &ex) { + _ERROR("on_message. Failed to parse json. {}\n{}", ex.what(), msg_str); + return; + } + if (msg.header.messageType == "heartbeat") { + on_heartbeat(msg); + return; + } + if (msg.header.messageType == "loginStatus") { + on_login_status(msg); + return; + } + if (msg.header.messageType == "subscriptionStatus") { + on_subscription_status(msg); + return; + } + auto hnds = topic_handlers.find(msg.header.messageType); + if (hnds != topic_handlers.end()) { + for (auto &hnd : hnds->second) { + hnd->on_message(msg); + } + } + } + + private: + static std::atomic session_id_counter_; +}; + +CmeWebsocketSession::CmeWebsocketSession(CmeWebsocketSessionConfig cfg) + : me_(std::make_unique(std::move(cfg))) { + me_->client.message_handler().bind<&PImpl::on_message>(*me_); +} + +CmeWebsocketSession::~CmeWebsocketSession() = default; + +std::atomic_int CmeWebsocketSession::PImpl::session_id_counter_ = 0; + +void CmeWebsocketSession::start() { me_->client.connect(); } + +std::string CmeWebsocketSession::subscribe( + std::vector< + std::tuple> + topic_handlers) { + vector products; + vector topics; + for (auto &[p, t, h] : topic_handlers) { + if (std::find(products.begin(), products.end(), p) == products.end()) { + products.push_back(p); + } + if (std::find(topics.begin(), topics.end(), t) == topics.end()) { + topics.push_back(t); + } + me_->topic_handlers[topic_incoming_name(t)].push_back(h); + } + auto cme_req = me_->req_factory_.subscription(products, topics); + if (!me_->client.is_connected()) { + throw std::runtime_error{ + "Unable to add subscription because client is not connected."}; + } + me_->client.send_text(JsonDumper::dump(sub_it->second.request)); + return *sub_it->second.request.header.requestId; +} + +bool CmeWebsocketSession::unsubscribe(const string &id) { + // TODO + auto it = me_->topic_handlers.find(id); + if (it == me_->subscriptions.end()) { + return false; + } + CmeWebsocketRequest req = it->second.request; + req.header.messageType = "unsubscribe"; + req.header.sentTime = core::TimeStamp::now(); + me_->subscriptions.erase(it); + me_->client.send_text(JsonDumper::dump(req)); + return true; +} + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.h b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.h new file mode 100644 index 000000000..48089bc8a --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session.h @@ -0,0 +1,58 @@ +#pragma once + +#include "bts-cme-websocket/cme_message_handler.h" +#include "bts-cme-websocket/cme_subscription_id.h" +#include "bts-cme-websocket/cme_subscription_topic.h" +#include "bts-cme-websocket/messages/cme_product_key.h" +#include "bts-cme-websocket/messages/cme_websocket_request.h" +#include "bts-http/URL.h" +#include "bts-system/delegate.h" +#include "bts-system/value_wrapper.h" + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace bts::websocket { + +class CmeOauthConfig; +class CmeWebsocketSessionConfig; + +class CmeWebsocketSession { + public: + explicit CmeWebsocketSession(CmeWebsocketSessionConfig cfg); + ~CmeWebsocketSession(); + + void start(); + + using MessageHandlerPtr = std::shared_ptr; + + /** + * Subscribes to topics for the specified products (a handler is + * paired with each topic). + */ + void subscribe( + std::vector< + std::tuple> + topic_handlers); + + bool unsubscribe( + std::vector< + std::tuple> + topic_handlers); + + private: + struct PImpl; + std::unique_ptr me_; +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session_config.h b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session_config.h new file mode 100644 index 000000000..e2aa6b7e0 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/cme_websocket_session_config.h @@ -0,0 +1,61 @@ +#pragma once + +#include "bts-cme-websocket/cme_subscription_topic.h" +#include "bts-cme-websocket/messages/cme_product_key.h" +#include "bts-cme-websocket/messages/cme_websocket_request.h" +#include "bts-http/URL.h" +#include "bts-http/oauth_request.h" +#include "bts-system/json/json_reader.h" +#include "bts-system/threading/thread_config.h" +#include "bts-websocket/websocket_client_config.h" + +#include +#include +#include +#include + +namespace bts::websocket { + +class CmeWebsocketSessionConfig { + public: + struct SubscriptionConfig { + std::vector topics; + std::vector products; + }; + + // Needed to obtain the access token (ignored if access token is non-empty) + websocket::WebsocketClientConfig websocket; + std::vector subscriptions; +}; + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline void to_json( + nlohmann::json &j, + const CmeWebsocketSessionConfig::SubscriptionConfig &cfg) { + j["topics"] = cfg.topics; + j["products"] = cfg.products; +} + +inline void from_json( + const nlohmann::json &j, + CmeWebsocketSessionConfig::SubscriptionConfig &cfg) { + system::json::JsonReader jr{&j}; + jr.read("topics", cfg.topics); + jr.read("products", cfg.products); +}; + +inline void to_json(nlohmann::json &j, const CmeWebsocketSessionConfig &cfg) { + j["websocket"] = cfg.websocket; + j["subscriptions"] = cfg.subscriptions; +} + +inline void from_json(const nlohmann::json &j, CmeWebsocketSessionConfig &cfg) { + system::json::JsonReader jr{&j}; + jr.read("websocket", cfg.websocket); + jr.read("subscriptions", cfg.subscriptions); +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_book_level.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_book_level.h new file mode 100644 index 000000000..d0e967b10 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_book_level.h @@ -0,0 +1,33 @@ +#pragma once + +#include "bts-system/TimeStamp.h" + +#include +#include + +namespace bts::websocket { + +class CmeBookLevel { + public: + core::TimeStamp lastUpdateTime; + std::uint32_t orderCnt; + double price; + double qty; +}; + +inline void to_json(nlohmann::json &j, const CmeBookLevel &l) { + j["lastUpdateTime"] = l.lastUpdateTime.to_iso_string(); + j["orderCnt"] = l.orderCnt; + j["price"] = l.price; + j["qty"] = l.qty; +} + +inline void from_json(const nlohmann::json &j, CmeBookLevel &l) { + l.lastUpdateTime = core::TimeStamp::from_iso_string( + j.at("lastUpdateTime").get()); + j.at("orderCnt").get_to(l.orderCnt); + j.at("price").get_to(l.price); + j.at("qty").get_to(l.qty); +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument.h new file mode 100644 index 000000000..2d37a9e59 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument.h @@ -0,0 +1,90 @@ +#pragma once + +#include "bts-system/TimeStamp.h" +#include +#include +#include + +namespace bts::websocket { + +class CmeInstrument { + public: + std::string guid; + std::int64_t guidInt; + std::int64_t productGuidInt; + std::string instrumentName; + std::optional globexSecurityId; + std::string globexSymbol; + core::TimeStamp positionRemovalDate; + core::TimeStamp lastUpdated; + core::TimeStamp lastTradeDate; + std::optional lastNoticeDate; + core::TimeStamp lastDeliveryDate; + std::optional globexLastTradeDate; + std::optional globexFirstTradeDate; + core::TimeStamp firstTradeDate; + std::optional firstNoticeDate; + core::TimeStamp firstDeliveryDate; + core::TimeStamp finalSettlementDate; + std::optional initialInventoryDueDate; + std::optional lastInventoryDueDate; + std::optional lastEfpDate; + std::optional strikePxCcy; + std::optional putCallIndicator; + std::optional priceBandD1; + std::optional priceBand; + std::optional zeroPriceEligible; + std::optional originalContractSize; + core::TimeStamp contractMonth; + std::string flexIndicator; + // TODO: like 40 more fields :()! + template + static void write_opt( + const std::optional &dest, + nlohmann::json &j, + const std::string &field) { + if (dest) { + j.at(field) = *dest; + } + } + + template + static void read_opt( + nlohmann::json &j, const std::string &field, std::optional &dest) { + auto it = j.find(field); + if (it != j.end()) { + it->get_to(dest.emplace()); + } + } +}; + +inline void to_json(nlohmann ::json &j, const CmeInstrument &i) { + j["guid"] = i.guid; + j["guidInt"] = i.guidInt; + j["productGuidInt"] = i.productGuidInt; + j["instrumentName"] = i.instrumentName; + if (i.globexSecurityId) { + j["globexSecurityId"] = *i.globexSecurityId; + } + j["globexSymbol"] = i.globexSymbol; + if (i.positionRemovalDate) { + // TODO + // j["positionRemovalDate"] = {}; + } + j["lastUpdated"] = i.lastUpdated; + j["lastTradeDate"] = i.lastTradeDate; +} + +inline void from_json(const nlohmann ::json &j, CmeInstrument &i) { + j.at("guid").get_to(i.guid); + j.at("guidInt").get_to(i.guidInt); + j.at("productGuidInt").get_to(i.productGuidInt); + j.at("instrumentName").get_to(i.instrumentName); + j.at("globexSecurityId").get_to(i.globexSecurityId); + j.at("globexSymbol").get_to(i.globexSymbol); + j.at("positionRemovalDate").get_to(i.positionRemovalDate); + j.at("lastUpdated").get_to(i.lastUpdated); + j.at("lastTradeDate").get_to(i.lastTradeDate); +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument_metadata.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument_metadata.h new file mode 100644 index 000000000..1ebe6c520 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_instrument_metadata.h @@ -0,0 +1,33 @@ +#pragma once + +#include +#include + +namespace bts::websocket { + +class CmeInstrumentMetadata { + public: + std::string definitionSource; + std::string exchangeMic; + std::int64_t id; + std::uint32_t marketSegmentId; + std::uint32_t periodCode; + std::string productCode; + std::string productType; + std::string productGroup; + std::string symbol; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE( + CmeInstrumentMetadata, + definitionSource, + exchangeMic, + id, + marketSegmentId, + periodCode, + productCode, + productType, + productGroup, + symbol); + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message.h new file mode 100644 index 000000000..c9a7c4eb3 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message.h @@ -0,0 +1,35 @@ +#pragma once + +#include "bts-cme-websocket/messages/cme_message_header.h" + +#include + +namespace bts::websocket { + +template +class CmeMessageT { + public: + CmeMessageHeader header; + std::optional payload; +}; + +using CmeMessage = CmeMessageT; + +template +inline void to_json(nlohmann::json &j, const CmeMessageT &msg) { + j["header"] = msg.header; + if (msg.payload) { + j["payload"] = *msg.payload; + } +} + +template +inline void from_json(const nlohmann::json &j, CmeMessageT &msg) { + j.at("header").get_to(msg.header); + auto payload = j.find("payload"); + if (payload != j.end()) { + payload->get_to(msg.payload.emplace()); + } +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message_header.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message_header.h new file mode 100644 index 000000000..b93ca3457 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_message_header.h @@ -0,0 +1,53 @@ +#pragma once + +#include "bts-system/TimeStamp.h" +#include "bts-system/json/json_reader.h" +#include "bts-cme-websocket/cme_subscription_id.h" + +#include +#include +#include +#include + +namespace bts::websocket { + +class CmeMessageHeader { + public: + std::string messageType{}; + std::optional requestId{}; + std::optional sentTime{}; + std::string token{}; + std::optional version{}; +}; + +inline void to_json(nlohmann ::json &j, const CmeMessageHeader &h) { + j["messageType"] = h.messageType; + if (h.sentTime) { + j["sentTime"] = h.sentTime->to_iso_extended_string(); + } + if (h.version) { + j["version"] = *h.version; + } + if (h.requestId) { + j["requestId"] = *h.requestId; + } +} + +inline void from_json(const nlohmann ::json &j, CmeMessageHeader &h) { + j.at("messageType").get_to(h.messageType); + std::string sentTime; + h.sentTime = + system::json::JsonReader{&j}.read("sentTime", sentTime) + ? decltype(h.sentTime){core::TimeStamp::from_iso_string(sentTime)} + : std::nullopt; + std::string version; + h.version = system::json::JsonReader{&j}.read("version", version) + ? decltype(h.version){version} + : std::nullopt; + std::string requestId; + h.requestId = system::json::JsonReader{&j}.read("requestId", requestId) + ? decltype(h.requestId){requestId} + : std::nullopt; +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_product_key.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_product_key.h new file mode 100644 index 000000000..a212055c4 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_product_key.h @@ -0,0 +1,28 @@ +#pragma once + +#include +#include + +namespace bts::websocket { + +class CmeProductKey { + public: + std::string exchangeMic; + std::string productType; + std::string productCode; +}; + +inline bool operator==(const CmeProductKey &lhs, const CmeProductKey &rhs) { + return lhs.exchangeMic == rhs.exchangeMic && + lhs.productType == rhs.productType && + lhs.productCode == rhs.productCode; +} + +inline bool operator!=(const CmeProductKey &lhs, const CmeProductKey &rhs) { + return !(lhs == rhs); +} + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE( + CmeProductKey, exchangeMic, productType, productCode); + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary.h new file mode 100644 index 000000000..d4320accc --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary.h @@ -0,0 +1,28 @@ +#pragma once + +#include +#include +#include + +namespace bts::websocket { + +class CmeTradeSummary { + public: + std::int64_t aggressorSide; + std::int64_t mdTradeEntryId; + double tradePrice; + double tradeQty; + std::uint32_t tradeOrderCount; + std::string tradeUpdateAction; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE( + CmeTradeSummary, + aggressorSide, + mdTradeEntryId, + tradePrice, + tradeQty, + tradeOrderCount, + tradeUpdateAction) + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary_payload.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary_payload.h new file mode 100644 index 000000000..d76a5b733 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_trade_summary_payload.h @@ -0,0 +1,19 @@ +#pragma once + +#include "bts-cme-websocket/messages/cme_trade_summary.h" + +#include +#include + +namespace bts::websocket { + +class CmeTradeSummaryPayload { + public: + std::int64_t lastUpdateTime; + CmeTradeSummary tradeSummary; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE( + CmeTradeSummaryPayload, lastUpdateTime, tradeSummary) + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request.h new file mode 100644 index 000000000..76cf51007 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request.h @@ -0,0 +1,10 @@ +#pragma once + +#include "bts-cme-websocket/messages/cme_message.h" +#include "bts-cme-websocket/messages/cme_websocket_request_payload.h" + +namespace bts::websocket { + +using CmeWebsocketRequest = CmeMessageT; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_factory.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_factory.h new file mode 100644 index 000000000..9a459ef40 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_factory.h @@ -0,0 +1,63 @@ +#pragma once + +#include "bts-cme-websocket/cme_subscription_topic.h" +#include "bts-cme-websocket/messages/cme_message_header.h" +#include "bts-cme-websocket/messages/cme_product_key.h" +#include "bts-cme-websocket/messages/cme_websocket_request.h" + +#include + +namespace bts::websocket { + +class CmeWebsocketRequestFactory { + public: + CmeWebsocketRequest subscription( + const std::vector &subscriptions, + const std::vector &topics); + + CmeWebsocketRequest unsubscription( + const std::vector &subscriptions, + const std::vector &topics); + + private: + // Ensure unique ids for each request + std::atomic id_counter_; +}; + +////////////////////////////////////////////////// +// Definition +////////////////////////////////////////////////// + +inline CmeWebsocketRequest CmeWebsocketRequestFactory::subscription( + const std::vector &products, + const std::vector &topics) { + CmeWebsocketRequest sub; + sub.payload.emplace(); + sub.payload->subscriptions = std::move(products); + sub.payload->subscriptionMessageTypes.reserve(topics.size()); + for (const auto t : topics) { + sub.payload->subscriptionMessageTypes.push_back(topic_outgoing_name(t)); + } + sub.header.requestId = std::to_string(id_counter_++); + sub.header.messageType = "subscribe"; + sub.header.sentTime = core::TimeStamp::now(); + return sub; +} + +inline CmeWebsocketRequest CmeWebsocketRequestFactory::unsubscription( + const std::vector &products, + const std::vector &topics) { + CmeWebsocketRequest sub; + sub.payload.emplace(); + sub.payload->subscriptions = std::move(products); + sub.payload->subscriptionMessageTypes.resize(topics.size()); + for (const auto t : topics) { + sub.payload->subscriptionMessageTypes.push_back(topic_outgoing_name(t)); + } + sub.header.requestId = std::to_string(id_counter_++); + sub.header.messageType = "unsubscribe"; + sub.header.sentTime = core::TimeStamp::now(); + return sub; +} + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_payload.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_payload.h new file mode 100644 index 000000000..898ca1be4 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/cme_websocket_request_payload.h @@ -0,0 +1,18 @@ +#pragma once + +#include "bts-cme-websocket/cme_subscription_topic.h" +#include "bts-cme-websocket/messages/cme_product_key.h" + +#include + +namespace bts::websocket { + +struct CmeWebsocketRequestPayload { + std::vector subscriptions; + std::vector subscriptionMessageTypes; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE( + CmeWebsocketRequestPayload, subscriptions, subscriptionMessageTypes); + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/private_order_qty.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/private_order_qty.h new file mode 100644 index 000000000..47c6367e0 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/private_order_qty.h @@ -0,0 +1,17 @@ +#pragma once + +#include +#include +#include + +namespace bts::websocket { + +class PrivateOrderQty { + public: + std::int64_t orderId; + double lastOrderQty; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(PrivateOrderQty, orderId, lastOrderQty) + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/messages/top_of_book.h b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/top_of_book.h new file mode 100644 index 000000000..6ea73363e --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/messages/top_of_book.h @@ -0,0 +1,22 @@ +#pragma once + +#include "bts-cme-websocket/messages/cme_book_level.h" +#include "bts-cme-websocket/messages/cme_instrument_metadata.h" +#include +#include +#include + +namespace bts::websocket { + +class TopOfBookPayload { + public: + std::string tradingStatus; + CmeInstrumentMetadata instrument; + std::vector askLevel; + std::vector bidLevel; +}; + +NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE( + TopOfBookPayload, tradingStatus, instrument, askLevel, bidLevel); + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.cpp b/src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.cpp new file mode 100644 index 000000000..0bd17b3b7 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.cpp @@ -0,0 +1,120 @@ +#include "ssl_certificate_verifier.h" + +namespace bts::websocket { + +/// Verify that the certificate common name matches the given hostname +bool SslCertificateVerifier::verify_common_name(char const *hostname, X509 *cert) { + // Find the position of the CN field in the Subject field of the certificate + int common_name_loc = X509_NAME_get_index_by_NID( + X509_get_subject_name(cert), NID_commonName, -1); + if (common_name_loc < 0) { + return false; + } + + // Extract the CN field + X509_NAME_ENTRY *common_name_entry = + X509_NAME_get_entry(X509_get_subject_name(cert), common_name_loc); + if (common_name_entry == NULL) { + return false; + } + + // Convert the CN field to a C string + ASN1_STRING *common_name_asn1 = X509_NAME_ENTRY_get_data(common_name_entry); + if (common_name_asn1 == NULL) { + return false; + } + + char const *common_name_str = + (char const *)ASN1_STRING_get0_data(common_name_asn1); + + // Make sure there isn't an embedded NUL character in the CN + if (static_cast(ASN1_STRING_length(common_name_asn1)) != + strlen(common_name_str)) { + return false; + } + + // Compare expected hostname with the CN + return (strcasecmp(hostname, common_name_str) == 0); +} + +/// Verify that one of the subject alternative names matches the given hostname +bool SslCertificateVerifier::verify_subject_alternative_name( + const char *hostname, X509 *cert) { + STACK_OF(GENERAL_NAME) *san_names = NULL; + + san_names = (STACK_OF(GENERAL_NAME) *)X509_get_ext_d2i( + cert, NID_subject_alt_name, NULL, NULL); + if (san_names == NULL) { + return false; + } + + int san_names_count = sk_GENERAL_NAME_num(san_names); + + bool result = false; + + for (int i = 0; i < san_names_count; i++) { + const GENERAL_NAME *current_name = sk_GENERAL_NAME_value(san_names, i); + + if (current_name->type != GEN_DNS) { + continue; + } + + char const *dns_name = + (char const *)ASN1_STRING_get0_data(current_name->d.dNSName); + + // Make sure there isn't an embedded NUL character in the DNS name + if (static_cast(ASN1_STRING_length(current_name->d.dNSName)) != + strlen(dns_name)) { + break; + } + // Compare expected hostname with the CN + result = (strcasecmp(hostname, dns_name) == 0); + } + sk_GENERAL_NAME_pop_free(san_names, GENERAL_NAME_free); + + return result; +} + +/** + * This code is derived from examples and documentation found ato00po + * http://www.boost.org/doc/libs/1_61_0/doc/html/boost_asio/example/cpp03/ssl/client.cpp + * and + * https://github.com/iSECPartners/ssl-conservatory + */ +bool SslCertificateVerifier::verify_certificate( + const char *hostname, + bool preverified, + boost::asio::ssl::verify_context &ctx) { + // The verify callback can be used to check whether the certificate that is + // being presented is valid for the peer. For example, RFC 2818 describes + // the steps involved in doing this for HTTPS. Consult the OpenSSL + // documentation for more details. Note that the callback is called once + // for each certificate in the certificate chain, starting from the root + // certificate authority. + + // Retrieve the depth of the current cert in the chain. 0 indicates the + // actual server cert, upon which we will perform extra validation + // (specifically, ensuring that the hostname matches. For other certs we + // will use the 'preverified' flag from Asio, which incorporates a number of + // non-implementation specific OpenSSL checking, such as the formatting of + // certs and the trusted status based on the CA certs we imported earlier. + int depth = X509_STORE_CTX_get_error_depth(ctx.native_handle()); + + // if we are on the final cert and everything else checks out, ensure that + // the hostname is present on the list of SANs or the common name (CN). + if (depth == 0 && preverified) { + X509 *cert = X509_STORE_CTX_get_current_cert(ctx.native_handle()); + + if (verify_subject_alternative_name(hostname, cert)) { + return true; + } else if (verify_common_name(hostname, cert)) { + return true; + } else { + return false; + } + } + + return preverified; +} + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.h b/src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.h new file mode 100644 index 000000000..caf166745 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/ssl_certificate_verifier.h @@ -0,0 +1,23 @@ +#pragma once + +#include +#include +#include +#include + +namespace bts::websocket { + +class SslCertificateVerifier { + public: + static bool verify_common_name(char const *hostname, X509 *cert); + + static bool verify_subject_alternative_name( + const char *hostname, X509 *cert); + + static bool verify_certificate( + const char *hostname, + bool preverified, + boost::asio::ssl::verify_context &ctx); +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.cpp b/src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.cpp new file mode 100644 index 000000000..36ab05b32 --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.cpp @@ -0,0 +1,42 @@ +#include "tls_initializer.h" +#include "bts-cme-websocket/ssl_certificate_verifier.h" +#include +#include +#include + +typedef websocketpp::client client; +typedef websocketpp::lib::shared_ptr + context_ptr; + +using websocketpp::lib::bind; +using websocketpp::lib::placeholders::_1; +using websocketpp::lib::placeholders::_2; + +namespace bts::websocket { + +context_ptr TlsInitializer::init( + const char *hostname, websocketpp::connection_hdl) { + context_ptr ctx = websocketpp::lib::make_shared( + boost::asio::ssl::context::sslv23); + + try { + ctx->set_options( + boost::asio::ssl::context::default_workarounds | + boost::asio::ssl::context::no_sslv2 | + boost::asio::ssl::context::no_sslv3 | + boost::asio::ssl::context::single_dh_use); + + // TODO: actually verify ssl certificate! + ctx->set_verify_mode(boost::asio::ssl::verify_none); + ctx->set_verify_callback(bind( + &SslCertificateVerifier::verify_certificate, hostname, ::_1, ::_2)); + + // Here we load the CA certificates of all CA's that this client trusts. + // ctx->load_verify_file("ca-chain.cert.pem"); + } catch (std::exception &e) { + std::cout << e.what() << std::endl; + } + return ctx; +} + +} // namespace bts::websocket diff --git a/src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.h b/src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.h new file mode 100644 index 000000000..6d7850b0f --- /dev/null +++ b/src/lib_bts-cme-websocket/bts-cme-websocket/tls_initializer.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include +#include + +namespace bts::websocket { + +class TlsInitializer { + public: + static websocketpp::lib::shared_ptr + init(const char *hostname, websocketpp::connection_hdl hdl); +}; + +} // namespace bts::websocket diff --git a/src/lib_bts-system/bts-system/HASH_IMPL.h b/src/lib_bts-system/bts-system/HASH_IMPL.h new file mode 100644 index 000000000..0b2d8ee35 --- /dev/null +++ b/src/lib_bts-system/bts-system/HASH_IMPL.h @@ -0,0 +1,15 @@ +#pragma once + +#include "bts-system/HashCombiner.h" + +#define _HASH_ARG(x) , std::hash{}(t.x) + +#define HASH_IMPL(type, for_all) \ + template <> \ + struct std::hash { \ + std::size_t operator()(const type &t) const noexcept { \ + std::size_t rv = 0; \ + bts::collections::HashCombiner::combine_hash(rv for_all(_HASH_ARG)); \ + return rv; \ + } \ + } diff --git a/src/lib_bts-system/bts-system/HashCombiner.h b/src/lib_bts-system/bts-system/HashCombiner.h new file mode 100644 index 000000000..ffbfd4aab --- /dev/null +++ b/src/lib_bts-system/bts-system/HashCombiner.h @@ -0,0 +1,27 @@ +#pragma once + +#include +#include + +namespace bts::collections { +class HashCombiner { + public: + template + static void combine_hash(std::size_t &seed, T arg); + + template + static void combine_hash(std::size_t &seed, T arg, T2... next); +}; + +template +void HashCombiner::combine_hash(std::size_t &seed, T arg) { + boost::hash_combine(seed, arg); +} + +template +void HashCombiner::combine_hash(std::size_t &seed, T arg, T2... next) { + boost::hash_combine(seed, arg); + combine_hash(seed, next...); +} + +} // namespace bts::collections