#ifndef _WIN32 #include "MBOServiceServer.h" #include "ExchangeOrderKey.h" #include "MBOProcessor.h" #include "MDClient.h" #include "lib/api/services/OrderService.client.pb.h" #include "lib/domain_model/Security.h" #include "lib/orderman/orderman_utils/orderman_common.h" #include "lib/utils/Dispatcher.h" #include "lib/utils/LockBox.h" #include #include using namespace bts::api::orderman; namespace bts { namespace md { // // Simple class to handle MD recovery and maintain an index of // SecurityKey=>MDConsumerHandle class HandleIndex { MDClient &_client; int _sub; std::optional _consumer; public: utils::LockBox> index; HandleIndex(md::MDClient &client) : _client(client), _sub(0), _consumer(std::nullopt), index() { _sub = _client.on_consumer().subscribe( [=, this](const MDConsumer &c) { on_consumer(c); }); on_consumer(_client.current_consumer()); } ~HandleIndex() { _client.on_consumer().unsubscribe(_sub); } private: void on_consumer(const MDConsumer &c) { MDConsumer temp(c); if (temp.all_heartbeats_ok()) { auto existing = _consumer ? _consumer->id() : 0; LOG(md, Info, "Updateing MBOService MDConsumer. Old {} new {}", existing, temp.id()); // clear the index index.lock([](auto &index) { index.clear(); }); // Swap to new consumer if (_consumer) { _consumer->swap(temp); } else { _consumer = temp; } // Subscribe to on_security auto id = _consumer->id(); _consumer->on_security( [this, id](const SecurityPtr &, MDConsumerHandle handle) { if (_consumer->id() == id) { index.lock([handle](auto &index) { index[SecurityKey(handle.key())] = handle; }); } }); } } }; class ActiveOrder { SecurityKey _security; SparkOrderKey _id; ExchangeOrderKey _ex_id; int32_t _position; public: // empty constructor needed for unordered map operator[] // ActiveOrder(): _security(), _id(), _ex_id(), _position(-1) { // bts_assert(false); } ActiveOrder(SecurityKey sec, SparkOrderKey s, ExchangeOrderKey ex) : _security(sec), _id(s), _ex_id(ex), _position(-1) {} SecurityKey security_id() const { return _security; } SparkOrderKey id() const { return _id; } ExchangeOrderKey exchange_id() const { return _ex_id; } int32_t &position() { return _position; }; int32_t position() const { return _position; }; bool set_position(int32_t pos) { if (pos != _position) { _position = pos; return true; } return false; } OrderPIQ to_piq() const { OrderPIQ result; result.set_order_id(_id.value()); result.set_position(_position); return result; } }; // // MBOService struct MBOServiceImpl { MBOServiceImpl( api::ServiceContext &ctx, utils::Dispatcher &d, md::MDClient &c, MBOServiceBase::PiqPublisher &&pub) : dispatcher(d), client(c), orders(ctx.locate()), handle_index(c), publish(pub), timer(d, 200, [&]() { timer_tick(); }), orders_sub() {} utils::Dispatcher &dispatcher; md::MDClient &client; OrderService orders; HandleIndex handle_index; MBOServiceBase::PiqPublisher publish; utils::DispatcherTimer timer; rxcpp::composite_subscription orders_sub; std::unordered_map active; void timer_tick(); void flush(); }; /////////////////////// std::optional search_orders( const ExchangeOrderKey oid, const std::vector &orders) { IntPrice price = {}; size_t position = 0; for (size_t x = 0; x < orders.size(); ++x) { const auto &oo = orders[x]; if (oo.id == oid) { if (oo.price == price) return {position}; else return 0; } else if (price == oo.price) { position += oo.size; } else { price = oo.price; position = oo.size; } } return std::nullopt; } bool update_position(const HandleIndex &handles, ActiveOrder &order) { const auto &index = handles.index; auto handle = index.lock([id = order.security_id()](const auto &index) { auto iter = index.find(id); return iter != index.end() ? iter->second : MDConsumerHandle{}; }); if (handle.is_initialized()) { auto mbo = handle.get_mbo(); if (mbo) { auto search_result = search_orders(order.exchange_id(), mbo->bids); if (!search_result) { search_result = search_orders(order.exchange_id(), mbo->asks); } if (search_result) { return order.set_position(search_result.value()); } } } return false; } void MBOServiceImpl::timer_tick() { // Dispatcher thread std::vector rows; for (auto &pair : active) { if (update_position(handle_index, pair.second)) { rows.push_back(pair.second.to_piq()); } } if (!rows.empty()) { publish(nullptr, &rows, nullptr); } } const NativeOrderState *native_order_state(const OrderRecord &record) { switch (record.state().custom_case()) { case OrderState::kMarket: return &record.state().market().native_state(); case OrderState::kLimit: return &record.state().limit().native_state(); case OrderState::kStop: return &record.state().stop().native_state(); case OrderState::kStopLimit: return &record.state().stop_limit().native_state(); case OrderState::kGlbxIceberg: return &record.state().glbx_iceberg().native_state(); default: return nullptr; } } bool is_active_exchange_order(const OrderRecord &record) { return record.state().status() == ORDER_STATUS_WORKING && native_order_state(record) != nullptr; } void try_remove( MBOServiceImpl &me, std::set &to_remove, const OrderRecord &record) { auto key = SparkOrderKey(record.key()); auto iter = me.active.find(key); if (iter != me.active.end()) { me.active.erase(key); to_remove.insert(key.value()); } } void try_add( MBOServiceImpl &me, std::vector &to_add, const OrderRecord &record) { if (is_active_exchange_order(record)) { auto native = native_order_state(record); auto ex_key = orderman::get_exchange_order_id(*native); auto u64_key = std::visit( overloaded{ [](orderman::ExchangeOrderID const &str) { return std::stoul(str.value().data()); }, [](orderman::ExchangeOrderID64 oid) { return oid.value(); }}, ex_key); bts_assert(native); ActiveOrder order( SecurityKey(record.def().security_key()), SparkOrderKey(record.key()), ExchangeOrderKey{u64_key}); update_position(me.handle_index, order); to_add.push_back(order.to_piq()); me.active.insert(std::make_pair(order.id(), order)); } } MBOServiceServer::MBOServiceServer( api::ServiceContext &ctx, utils::Dispatcher &d, md::MDClient &c) : MBOServiceBase(ctx), _me(new MBOServiceImpl(ctx, d, c, make_piq_publisher())) { // subscribe to mdclient ✔ // make publishers ✔ // subscribe to orders => stash active orders dict _me->orders_sub = _me->orders.subscribe_orders().subscribe([=, this](const auto &update) { // api thread const auto &added = update.added(); const auto &changed = update.changed(); const auto &removed = update.removed(); _me->dispatcher.post([this, added, changed, removed]() { // dispatcher thread std::vector to_add, to_change; std::set to_remove; // Remove for (const auto &r : removed) { // If it was active remove it and add to to_remove try_remove(*_me, to_remove, *r); } // Added for (const auto &add : added) { // If active add look up the position and add to the state try_add(*_me, to_add, *add); } // Changed for (const auto &ch : changed) { // new order is active and old is not look up piq and add to // state bool is_active = is_active_exchange_order(*ch.current()); bool was_active = is_active_exchange_order(*ch.previous()); if (is_active && !was_active) { try_add(*_me, to_add, *ch.current()); } else if (was_active && !is_active) { try_remove(*_me, to_remove, *ch.current()); } // is_active && was_active => don't care // !is_active && !was_active => don't care } _me->publish(&to_add, &to_change, &to_remove); if (!_me->timer.running()) _me->timer.start(); }); }); } MBOServiceServer::~MBOServiceServer() {} void MBOServiceServer::get_orders_for_security( const MBOSecurityQuery &request, const api::Response &reply) { PositionData response; response.set_security_id(request.security_id()); auto handle = _me->handle_index.index.lock( [id = request.security_id()](const auto &index) { auto iter = index.find(SecurityKey(id)); return iter != index.end() ? iter->second : MDConsumerHandle{}; }); std::unordered_map reverse; for (const auto &pair : _me->active) { reverse.insert(std::make_pair(pair.second.exchange_id(), pair.first)); } size_t count = 0; auto tick = handle.get_minimum_tick(); if (handle.is_initialized()) { auto mbo = handle.get_mbo(); if (mbo) { for (const auto &o : mbo->bids) { double price = o.price.price(); bool isnan = os::is_nan(request.price_level()); if (isnan || securities::test_price_equality( request.price_level(), price, tick)) { ++count; if (request.limit() && count > request.limit()) break; auto *entry = response.add_bid(); entry->set_exchange_id(o.id.value()); if (isnan) entry->set_price(price); entry->set_size(o.size); auto iter = reverse.find(o.id); if (iter != reverse.end()) { entry->set_order_id(iter->second.value()); } } } for (const auto &o : mbo->asks) { double price = o.price.price(); bool isnan = os::is_nan(request.price_level()); if (isnan || securities::test_price_equality( request.price_level(), price, tick)) { ++count; if (request.limit() && count > request.limit()) break; auto *entry = response.add_ask(); entry->set_exchange_id(o.id.value()); if (isnan) entry->set_price(price); entry->set_size(o.size); auto iter = reverse.find(o.id); if (iter != reverse.end()) { entry->set_order_id(iter->second.value()); } } } } } reply(response); } } // namespace md } // namespace bts #endif