From 3078b918d2f7f4e9abe7dd3d669525916f75eb20 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 16 May 2023 14:47:41 +0000 Subject: [PATCH] CLeaning up --- src/lib/orderman/OrderServiceServer.cpp | 2 +- .../orderman/ccapi/CCAPIConnectionConfig.h | 3 +- .../orderman/ccapi/CCAPIDeribitOrderMux.cpp | 184 +++++------ src/lib/orderman/ccapi/CCAPIDeribitOrderMux.h | 22 +- src/lib/orderman/ccapi/CCAPIOrderState.h | 24 +- .../ccapi/CCAPISingleOrderManager.cpp | 82 ++--- .../orderman/ccapi/CCAPISingleOrderManager.h | 28 +- src/lib/orderman/ccapi/ICCAPIOrderMux.h | 6 +- .../gateways/CCAPIExecutionGateway.cpp | 290 ++++++++++++------ .../orderman/gateways/CCAPIExecutionGateway.h | 14 + 10 files changed, 365 insertions(+), 290 deletions(-) diff --git a/src/lib/orderman/OrderServiceServer.cpp b/src/lib/orderman/OrderServiceServer.cpp index f89d3d326..65f7b8571 100644 --- a/src/lib/orderman/OrderServiceServer.cpp +++ b/src/lib/orderman/OrderServiceServer.cpp @@ -522,7 +522,7 @@ void OrderServiceServer::_on_exchange_position( ret_pos.set_avg_filled_price(p.avg_filled_price.value()); ret_pos.set_position(p.position); me->exchange_pos_publisher.add_or_update(ret_pos); - LOG(OrderMan, Info, "OrderServiceServer::_on_exchange_position pos: {}", + LOG(OrderMan, Diag, "OrderServiceServer::_on_exchange_position pos: {}", utils::pb::to_string(ret_pos)); } LOG(OrderMan, Info, diff --git a/src/lib/orderman/ccapi/CCAPIConnectionConfig.h b/src/lib/orderman/ccapi/CCAPIConnectionConfig.h index b2c40fb6d..e7f0484cd 100644 --- a/src/lib/orderman/ccapi/CCAPIConnectionConfig.h +++ b/src/lib/orderman/ccapi/CCAPIConnectionConfig.h @@ -11,15 +11,14 @@ namespace bts::orderman { struct CCAPIConnectionConfig { public: + std::string internal_account; struct DeribitConnectionConfig { std::string client_id; std::string client_secret; - std::string internal_account; }; struct BinanceConnectionConfig { std::string client_id; std::string client_secret; - std::string internal_account; }; std::variant connection_config; diff --git a/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.cpp b/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.cpp index ed83f2419..ab2a95d1e 100644 --- a/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.cpp +++ b/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.cpp @@ -46,14 +46,14 @@ namespace bts::orderman { // For threading reasons, it just queues the message which is then dequeued // in dispatch_incoming_messages class OrderEventHandler : public ccapi::EventHandler { - boost::lockfree::spsc_queue &event_queue; + boost::lockfree::spsc_queue &dispatch_queue; std::set event_types; public: OrderEventHandler( - boost::lockfree::spsc_queue &event_queue, + boost::lockfree::spsc_queue &dispatch_queue, const std::vector &event_types) - : event_queue(event_queue), + : dispatch_queue(dispatch_queue), event_types(event_types.begin(), event_types.end()) {} bool processEvent( const ccapi::Event &event, ccapi::Session *session) override { @@ -65,11 +65,12 @@ class OrderEventHandler : public ccapi::EventHandler { "event: {}", os::get_thread_id(), interested, event.toStringPretty(2, 2)); if (interested) - event_queue.push(event); + dispatch_queue.push(event); return true; } }; +// Struct to organize the periodic requesting or positons and orders struct PositionOrderRequestHelper { struct PosData { std::string currency; @@ -114,15 +115,17 @@ struct PositionOrderRequestHelper { std::vector total_working_orders() const { std::vector rv = {}; for (const auto &kv : curr_ord_map) { - const auto &pos = kv.second.order_vec; - rv.insert(rv.end(), pos.begin(), pos.end()); + const auto &ords = kv.second.order_vec; + rv.insert(rv.end(), ords.begin(), ords.end()); } return rv; } }; -// Sec state for the order and trade subs -struct SubscriptionStatus { +// Since we have to subscribe to the orders and trades for each instrument +// individually, this struct keeps the state of the subscription. Orders can +// only be sent once fully_subscribed() +struct SecOrdersTradesSubscriptionStatus { const uint32_t sec_id; const std::string order_sub_corr_id; const std::string trade_sub_corr_id; @@ -142,23 +145,21 @@ struct SubscriptionStatus { }; struct CCAPIDeribitOrderMux::PImpl { + const std::string internal_account; CCAPIConnectionConfig::DeribitConnectionConfig d_conn_config; const std::string missing_corrid_placeholder = "MISSING_CORRID"; - PositionOrderRequestHelper pos_ord_req = {}; + PositionOrderRequestHelper pos_ord_req_helper = {}; md::SecurityOracle sec_oracle; - ccapi::SessionOptions session_options = {}; - ccapi::SessionConfigs session_configs; ccapi::Session *session = nullptr; OnCCAPIOrderUpdate order_update_cb; OnCCAPIExchangePositionUpdate exchange_position_update_cb; OnCCAPIExchangeOpenOrderUpdate exchange_open_orders_update_cb; size_t corr_id = 0; std::map order_map = {}; - // std::set subscribed_sec_map = {}; boost::lockfree::spsc_queue incoming_event_queue; OrderEventHandler event_handler; // map of subscription confirmation for a security - std::unordered_map sub_map = {}; + std::unordered_map sub_map = {}; // if we get a new order for a security that we hve not subscribed to yet // (order updates and trades), we buffer the create message and send it once // we get subcriptions confirmation @@ -166,7 +167,8 @@ struct CCAPIDeribitOrderMux::PImpl { PImpl( const CCAPIConnectionConfig &connection_config, const md::SecurityOracle &md_oracle) - : sec_oracle(md_oracle), incoming_event_queue(100), + : internal_account(connection_config.internal_account), + sec_oracle(md_oracle), incoming_event_queue(100), event_handler( incoming_event_queue, {ccapi::Event::Type::RESPONSE, @@ -178,14 +180,14 @@ struct CCAPIDeribitOrderMux::PImpl { "CCAPIDeribitOrderMux::PImpl::cons client_id: {} client_secret: {} " "internal_account: {}", d_conn_config.client_id, d_conn_config.client_secret, - d_conn_config.internal_account); + internal_account); + ccapi::SessionConfigs session_configs; session_configs.setCredential({ {"grant_type", "client_signature"}, {CCAPI_DERIBIT_CLIENT_ID, d_conn_config.client_id}, {CCAPI_DERIBIT_CLIENT_SECRET, d_conn_config.client_secret}, }); - session = new ccapi::Session( - ccapi::Session(session_options, session_configs, &event_handler)); + session = new ccapi::Session({}, session_configs, &event_handler); } }; @@ -201,35 +203,18 @@ CCAPIDeribitOrderMux::CCAPIDeribitOrderMux( CCAPIDeribitOrderMux::~CCAPIDeribitOrderMux() {} -void CCAPIDeribitOrderMux::on_securities( - const bts::mercury::Update &update) { - LOG(OrderMan, Info, - "CCAPIDeribitOrderMux::on_securities t_id: {} t_name: {} n_secs: {}", - os::get_thread_id(), os::get_thread_name(), - update.events == nullptr ? 0 : update.events->size()); -} - CCAPIOpResult CCAPIDeribitOrderMux::launch_new_order( const CreateOrderMsg &cr_msg) { - LOG(OrderMan, Info, - "CCAPIDeribitOrderMux::launch_new_order tid: {} sec: {} ok: {} p: {} q: " - "{}", - os::get_thread_id(), utils::pb::to_string(*cr_msg.security), - cr_msg.key.value(), cr_msg.price, cr_msg.quantity); // order update subscription - bool alread_subbed = _check_and_add_subscription(*cr_msg.security); - if (alread_subbed) { - LOG(OrderMan, Warn, - "CCAPIDeribitOrderMux::launch_new_order sending order ok: {} right " - "away since subcriptions are ready", - cr_msg.key); + bool already_subbed = _check_and_add_subscription(*cr_msg.security); + LOG(OrderMan, Info, + "CCAPIDeribitOrderMux::launch_new_order tid: {} sec_key: {} ok: {} p: " + "{} q: {} already_subbed: {}", + os::get_thread_id(), cr_msg.security->id(), cr_msg.key.value(), + cr_msg.price, cr_msg.quantity, already_subbed); + if (already_subbed) { _send_order(cr_msg); } else { - LOG(OrderMan, Warn, - "CCAPIDeribitOrderMux::launch_new_order buffering order ok: {} " - "until subscriptions are confirmed", - cr_msg.key); - // buffer the order and send it once we get the sub confirmed me->buffered_creates.push_back(cr_msg); } // TODO, fire an ex report of waiting @@ -270,8 +255,7 @@ bool CCAPIDeribitOrderMux::update_order( ccapi::Request::Operation::GENERIC_PRIVATE_REQUEST, CCAPI_EXCHANGE_NAME_DERIBIT, sec_desc, corr_id); request.appendParam( - {// {CCAPI_HTTP_PROTOCOL, "https"}, - {CCAPI_HTTP_METHOD, "GET"}, + {{CCAPI_HTTP_METHOD, "GET"}, {CCAPI_HTTP_PATH, "/api/v2/private/edit"}, {CCAPI_HTTP_QUERY_STRING, query}, {CCAPI_HTTP_HEADERS, "Content-Type: application/json"}}); @@ -287,10 +271,7 @@ void send_cancel_generic_private_request( LOG(OrderMan, Info, "send_cancel_generic_private_request cc_order_key: {} sec_desc: {}", cc_order_key, sec_desc); - //"https://test.deribit.com/api/v2/private/cancel?order_id=ETH-SLIS-12" - - // std::string query = "cancel?order_id=" + cc_order_key; std::string query = "order_id=" + cc_order_key; std::string corr_id = "OrderCxl:" + cc_order_key; ccapi::Request request( @@ -311,16 +292,19 @@ bool CCAPIDeribitOrderMux::cancel_order(const CancelOrderMsg &cxl_msg) { cxl_msg.key, cxl_msg.exchange_order_id); auto it = me->order_map.find(cxl_msg.key); if (it == me->order_map.end()) { + LOG(OrderMan, Error, + "CCAPIDeribitOrderMux::cancel_order could not find order_key: {}", + cxl_msg.key); return false; } CCAPISingleOrderManager &order_man = it->second; const auto &sec_desc = order_man.order_state().security.deribit().security_desc(); - if (order_man.order_state().security.has_option()) { - send_cancel_generic_private_request( - me->session, order_man.order_state().cc_order_key, sec_desc); - return true; - } + // if (order_man.order_state().security.has_option()) { + // send_cancel_generic_private_request( + // me->session, order_man.order_state().cc_order_key, sec_desc); + // return true; + // } std::string corr_id = "OrderCxl:" + order_man.order_state().cc_order_key; ccapi::Request request( ccapi::Request::Operation::CANCEL_ORDER, CCAPI_EXCHANGE_NAME_DERIBIT, @@ -375,6 +359,8 @@ void CCAPIDeribitOrderMux::send_rfq(const RFQMsg &rfq) { if (rfq.rfq.has_security()) { const auto &sec = rfq.rfq.security(); if (sec.has_security_id()) { + // Security's ID being populated is a signal that its an existing security + // so we just need to send an RFQ instead of creating it const api::Security *sec_ptr = me->sec_oracle.get_security(SecurityKey(sec.security_id())); if (sec_ptr != nullptr) { @@ -405,29 +391,8 @@ void CCAPIDeribitOrderMux::send_rfq(const RFQMsg &rfq) { "sec_id: {}", sec.security_id()); } - } else if (sec.has_spread()) { - LOG(OrderMan, Info, "IEMOrderMuxer::send_rfq creating combo"); - // std::vector combos = {}; - // for (const auto &leg : sec.spread().legs()) { - // auto c = _convert_combo_trade(leg); - // if (!c.has_value()) { - // LOG(OrderMan, Error, - // "IEMOrderMuxer::send_rfq could not find security for " - // "spread leg"); - // return; - // } - // combos.push_back(c.value()); - // } - // std::vector combos_ptr = {}; - // for (const auto &c : combos) { - // combos_ptr.push_back(&c); - // } - // auto ti = me->trading_sessions.at(0); - // ti.trading_interface->create_combo(combos_ptr); } else { - LOG(OrderMan, Error, - "IEMOrderMuxer::send_rfq could not send RFQ security does not " - "have any of the oneof's set"); + // TODO: create combo } } else { LOG(OrderMan, Error, @@ -458,13 +423,7 @@ void CCAPIDeribitOrderMux::dispatch_incoming_messages() { me->order_update_cb(kv.second.order_state()); } } - // TODO: delete terminal state orders - // auto it = std::remove_if( - // me->order_map.begin(), me->order_map.end(), - // [](const std::pair &) { - // return true; - // }); - // me->order_map.erase(it, me->order_map.end()); + //TODO: delete terminal state orders } // Position @@ -474,7 +433,7 @@ void CCAPIDeribitOrderMux::query_positions() { std::vector reqs = {}; bool generic_req = true; if (generic_req) { - for (const auto &kv : me->pos_ord_req.curr_pos_map) { + for (const auto &kv : me->pos_ord_req_helper.curr_pos_map) { const PositionOrderRequestHelper::PosData &curr_pos = kv.second; const std::string &corrid = curr_pos.corrid; std::string pos_query = "currency=" + curr_pos.currency; @@ -490,6 +449,7 @@ void CCAPIDeribitOrderMux::query_positions() { reqs.push_back(pos_request); } } else { + // didnt work ! ccapi::Request request( ccapi::Request::Operation::GET_ACCOUNT_POSITIONS, CCAPI_EXCHANGE_NAME_DERIBIT, "", "corrid"); @@ -509,7 +469,7 @@ CCAPIDeribitOrderMux::exchange_position_update_cb() { void CCAPIDeribitOrderMux::query_open_orders() { LOG(OrderMan, Info, "CCAPIDeribitOrderMux::query_open_orders"); std::vector reqs = {}; - for (const auto &kv : me->pos_ord_req.curr_ord_map) { + for (const auto &kv : me->pos_ord_req_helper.curr_ord_map) { const PositionOrderRequestHelper::OrderData &curr_ord = kv.second; const std::string &corrid = curr_ord.corrid; std::string ord_query = "currency=" + curr_ord.currency; @@ -541,19 +501,19 @@ bool CCAPIDeribitOrderMux::_check_and_add_subscription( const api::Security &sec) { auto it = me->sub_map.find(sec.id()); if (it == me->sub_map.end()) { - auto order_status_sub_corrid = - "OrderSub:" + sec.deribit().security_desc(); - auto trade_sub_corrid = "TradeSub:" + sec.deribit().security_desc(); - SubscriptionStatus new_status{ + const auto &sec_desc = sec.deribit().security_desc(); + auto order_status_sub_corrid = "OrderSub:" + sec_desc; + auto trade_sub_corrid = "TradeSub:" + sec_desc; + SecOrdersTradesSubscriptionStatus new_status{ sec.id(), order_status_sub_corrid, trade_sub_corrid}; me->sub_map.insert({sec.id(), new_status}); - const auto &sec_desc = sec.deribit().security_desc(); LOG(OrderMan, Info, "CCAPIDeribitOrderMux::_check_and_add_subscription " "CCAPI_EM_ORDER_UPDATE and CCAPI_EM_PRIVATE_TRADE " "subscriptions for " "sec: {} order_status_sub_corrid: {} trade_sub_corrid: {}", sec_desc, order_status_sub_corrid, trade_sub_corrid); + // this is the only subscription we have in deribit execution code std::vector subs = {}; subs.emplace_back( CCAPI_EXCHANGE_NAME_DERIBIT, sec_desc, CCAPI_EM_ORDER_UPDATE, "", @@ -568,7 +528,8 @@ bool CCAPIDeribitOrderMux::_check_and_add_subscription( } } -// (Unused) Subscribes to all orders +// (Unused) this is supposed to subscribe for all instruments at once +// but does not work void CCAPIDeribitOrderMux::_subscribe_to_order_callbacks() { // this is not working bts_assert(false); @@ -626,19 +587,19 @@ void CCAPIDeribitOrderMux::_handle_element( case ccapi::Message::Type::CREATE_ORDER: { CCAPICreateOrderMsg cr_ord_msg(map, corr_id); for (auto &kv : me->order_map) - kv.second.handle_create(cr_ord_msg); + kv.second.handle_create_reponse(cr_ord_msg); break; } case ccapi::Message::Type::EXECUTION_MANAGEMENT_EVENTS_ORDER_UPDATE: { CCAPIOrderUpdateMsg ord_update_msg(map); for (auto &kv : me->order_map) - kv.second.handle_order_update(ord_update_msg); + kv.second.handle_order_sub_update(ord_update_msg); break; } case ccapi::Message::Type::EXECUTION_MANAGEMENT_EVENTS_PRIVATE_TRADE: { CCAPITradeMsg tr_msg(map); for (auto &kv : me->order_map) - kv.second.handle_trade(tr_msg); + kv.second.handle_trade_sub_update(tr_msg); break; } case ccapi::Message::Type::SUBSCRIPTION_STARTED: { @@ -652,25 +613,26 @@ void CCAPIDeribitOrderMux::_handle_element( break; } case ccapi::Message::Type::GENERIC_PRIVATE_REQUEST: { - // check for posiiton cb + // check for position cb PositionOrderRequestHelper::PosData *pos_data = - me->pos_ord_req.is_position_cb(corr_id); + me->pos_ord_req_helper.is_position_cb(corr_id); if (pos_data != nullptr) { pos_data->pos_vec.clear(); CCAPIDeribitHelpers::parse_open_position( - element, me->d_conn_config.internal_account, pos_data->pos_vec); - me->exchange_position_update_cb(me->pos_ord_req.total_positions()); + element, me->internal_account, pos_data->pos_vec); + me->exchange_position_update_cb( + me->pos_ord_req_helper.total_positions()); return; } PositionOrderRequestHelper::OrderData *ord_data = - me->pos_ord_req.is_order_cb(corr_id); + me->pos_ord_req_helper.is_order_cb(corr_id); if (ord_data != nullptr) { ord_data->order_vec.clear(); CCAPIDeribitHelpers::parse_working_position( - element, me->d_conn_config.client_id, - me->d_conn_config.internal_account, ord_data->order_vec); + element, me->d_conn_config.client_id, me->internal_account, + ord_data->order_vec); me->exchange_open_orders_update_cb( - me->pos_ord_req.total_working_orders()); + me->pos_ord_req_helper.total_working_orders()); return; } // orders @@ -692,8 +654,7 @@ void CCAPIDeribitOrderMux::_handle_subscription_status( const CCAPISubscriptionStatusMsg &ss_msg) { LOG(OrderMan, Info, "CCAPIDeribitOrderMux::_handle_subscription_status status: {} " - "corr_id: " - "{}", + "corr_id: {}", ss_msg.is_success, ss_msg.corr_id); if (ss_msg.is_success) { // 1. update the subscription state @@ -701,7 +662,7 @@ void CCAPIDeribitOrderMux::_handle_subscription_status( // 3. send the orders // 4. remove them from cached orders for (auto &kv : me->sub_map) { - SubscriptionStatus &ss = kv.second; + SecOrdersTradesSubscriptionStatus &ss = kv.second; auto subbed = ss.update_status(ss_msg.corr_id, ss_msg.is_success); if (subbed) { _send_buffered_orders(ss.sec_id); @@ -737,20 +698,22 @@ void CCAPIDeribitOrderMux::_send_order(const CreateOrderMsg &cr_msg) { : CCAPI_EM_ORDER_SIDE_SELL}, {CCAPI_EM_ORDER_QUANTITY, std::to_string(cr_msg.quantity.full_value())}, {CCAPI_EM_ORDER_LIMIT_PRICE, std::to_string(cr_msg.price.value())}}); - LOG(OrderMan, Info, "CCAPIDeribitOrderMux::_send_order sec: {} p: {} q: {}", - sec_desc, cr_msg.price, cr_msg.quantity); + LOG(OrderMan, Info, + "CCAPIDeribitOrderMux::_send_order sec: {} key: {} p: {} q: {}", + sec_desc, cr_msg.key, cr_msg.price, cr_msg.quantity); me->session->sendRequest(request); } // new orders that did not have a subscription were buffered in the -// buffered_creates vector +// buffered_creates vector. this gets a sec_id because subscriptions +// to orders / trades are for instrument void CCAPIDeribitOrderMux::_send_buffered_orders(uint32_t sec_id) { - for (auto &cr_msg : me->buffered_creates) { + for (const auto &cr_msg : me->buffered_creates) { if (cr_msg.security->id() == sec_id) { LOG(OrderMan, Info, - "CCAPIDeribitOrderMux::_send_buffered_orders sending " - "buffered " - "order"); + "CCAPIDeribitOrderMux::_send_buffered_orders sending buffered " + "order key: {}", + cr_msg.key.value()); _send_order(cr_msg); } } @@ -762,8 +725,7 @@ void CCAPIDeribitOrderMux::_send_buffered_orders(uint32_t sec_id) { }), me->buffered_creates.end()); LOG(OrderMan, Info, - "CCAPIDeribitOrderMux::_send_buffered_orders n_buffered_orders: " - "{}", + "CCAPIDeribitOrderMux::_send_buffered_orders n_buffered_orders: {}", me->buffered_creates.size()); } diff --git a/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.h b/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.h index 2f9d136ed..b4691a523 100644 --- a/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.h +++ b/src/lib/orderman/ccapi/CCAPIDeribitOrderMux.h @@ -4,7 +4,6 @@ #include "lib/orderman/CreateOrderMsg.h" #include "lib/orderman/ccapi/CCAPIConnectionConfig.h" #include "lib/orderman/ccapi/CCAPIOrderCallbackMsgs.h" -//#include "lib/domain_model/Security.pb.h" #include #include #include @@ -21,29 +20,20 @@ class CCAPIDeribitOrderMux : public ICCAPIOrderMux { public: CCAPIDeribitOrderMux( const CCAPIConnectionConfig &connection_config, - const md::SecurityOracle &); + const md::SecurityOracle &sec_oracle); ~CCAPIDeribitOrderMux(); - // System - void on_securities( - const bts::mercury::Update &update) override; - // Orders + // Orders ////////////////////////////////////////////////////////////////// CCAPIOpResult launch_new_order(const CreateOrderMsg &cr_msg) override; bool update_order(const CancelReplaceOrderMsg &cxl_repl_msg) override; - bool cancel_order(const CancelOrderMsg &) override; + bool cancel_order(const CancelOrderMsg &cxl_msg) override; void send_rfq(const RFQMsg &rfq) override; OnCCAPIOrderUpdate &order_update_cb() override; - // Dispatching incoming messages + // Incoming messages from the exchanges are processed and callbacks + // fired in this thread void dispatch_incoming_messages() override; - // Position - // //////////////////////////////////////////////////////////////// - //////////////////////////////////////////////////////////////////////////// - // This queries the exchange for the positions. the position is returned - // on the exchange_position_update_cb callback (below) - // TODO: account as a paremter + // Query exchange positions / orders /////////////////////////////////////// void query_positions() override; OnCCAPIExchangePositionUpdate &exchange_position_update_cb() override; - // Mass orders - // ///////////////////////////////////////////////////////////// void query_open_orders() override; OnCCAPIExchangeOpenOrderUpdate &exchange_open_orders_update_cb() override; diff --git a/src/lib/orderman/ccapi/CCAPIOrderState.h b/src/lib/orderman/ccapi/CCAPIOrderState.h index a4612bf7c..4e4869f9a 100644 --- a/src/lib/orderman/ccapi/CCAPIOrderState.h +++ b/src/lib/orderman/ccapi/CCAPIOrderState.h @@ -15,33 +15,28 @@ namespace bts::orderman { typedef std::string CCAPIOrderKey; -// this is the data returned from the Mux callback to the gateway +// this is the data representing the order state returned from the +// Mux callback to the gateway struct CCAPIOrderState { - - struct CCAPITradeRecord {}; - - struct CCAPISpreadLegFill {}; - const api::Security &security; const OrderKey order_key; const std::string cc_create_corr_id; const bts::api::Side side; + // this is not known at creation time, therefore not a const CCAPIOrderKey cc_order_key = ""; bts::api::orderman::OrderStatus status = bts::api::orderman::OrderStatus::ORDER_STATUS_PENDING_WORKING; - double order_px = - os::nan(); // copied only when qty > 0 (might not ne needed anymore) + double order_px = os::nan(); double order_qty = 0; double total_fills = 0; double avg_filled_price = 0; + // the following are not accumulated state measures, but rather transitional + // and represent the last callback double last_filled_qty = 0; double last_filled_price = 0; - // these are not the accumulated trades but trades that happened bw last - // callback and now boost::container::small_vector cb_trades = {}; - // leg fills corresponding to the above trades (optional) (lifecycle is the - // same as above - boost::container::small_vector cb_leg_trades = {}; + boost::container::small_vector cb_leg_trades = {}; + // these are statistics of incoming an outgoing messages respectively size_t n_cbs = 0; size_t n_outgoing_mods = 0; @@ -66,7 +61,8 @@ inline std::ostream &operator<<(std::ostream &out, CCAPIOrderState const &s) { << " order_px: " << s.order_px << " order_qty: " << s.order_qty << " total_fills: " << s.total_fills << " avg_filled_price: " << s.avg_filled_price - << " n_trades: " << s.cb_trades.size(); + << " n_trades: " << s.cb_trades.size() << " n_cbs: " << s.n_cbs + << " n_outgoing_mods: " << s.n_outgoing_mods; return out; } diff --git a/src/lib/orderman/ccapi/CCAPISingleOrderManager.cpp b/src/lib/orderman/ccapi/CCAPISingleOrderManager.cpp index c5b5d3d5e..f2e7b9ba0 100644 --- a/src/lib/orderman/ccapi/CCAPISingleOrderManager.cpp +++ b/src/lib/orderman/ccapi/CCAPISingleOrderManager.cpp @@ -10,11 +10,12 @@ namespace bts::orderman { +// Represents the state machine for this class enum class CCAPISingleOrderManager::State { - WaitingForID, - Working, - EndWaitingForFills, - End + WAITING_FOR_ID, + WORKING, + END_WAITING_FOR_FILLS, + END }; static bool eq(double p1, double p2) { return securities::eq(p1, p2); } @@ -59,7 +60,7 @@ struct PreviousState { struct CCAPISingleOrderManager::PImpl { CCAPIOrderState order; PreviousState prev_state = {}; - State state = State::WaitingForID; + State state = State::WAITING_FOR_ID; std::vector buffered_order_updates = {}; std::vector buffered_trades = {}; double accumulated_fills = 0; @@ -101,15 +102,15 @@ CCAPISingleOrderManager::CCAPISingleOrderManager( CCAPISingleOrderManager::~CCAPISingleOrderManager() {} -void CCAPISingleOrderManager::handle_create( +void CCAPISingleOrderManager::handle_create_reponse( const CCAPICreateOrderMsg &create_order_msg) { LOG(OrderMan, Info, "CCAPISingleOrderManager::handle_create ok: {} corr_id: {} " "cc_order_key: {} state: {}", me->order.order_key, me->order.cc_create_corr_id, me->order.cc_order_key, - state_msg(me->state)); + _state_msg(me->state)); switch (me->state) { - case State::WaitingForID: + case State::WAITING_FOR_ID: // copy create state me->order.cc_order_key = create_order_msg.order_id; me->order.status = create_order_msg.status; @@ -142,36 +143,36 @@ void CCAPISingleOrderManager::handle_create( me->buffered_order_updates.clear(); if (in_terminal_state(me->order.status)) { if (me->fills_accounted()) { - _switch_state(State::End); + _switch_state(State::END); } else { - _switch_state(State::EndWaitingForFills); + _switch_state(State::END_WAITING_FOR_FILLS); } } else { - _switch_state(State::Working); + _switch_state(State::WORKING); } break; - case State::Working: + case State::WORKING: if (me->order.cc_order_key == create_order_msg.order_id) LOG(OrderMan, Error, "CCAPISingleOrderManager::handle_create ok: {} state: {}", - me->order.order_key, state_msg(me->state)); + me->order.order_key, _state_msg(me->state)); break; - case State::EndWaitingForFills: + case State::END_WAITING_FOR_FILLS: if (me->order.cc_order_key == create_order_msg.order_id) LOG(OrderMan, Error, "CCAPISingleOrderManager::handle_create ok: {} state: {}", - me->order.order_key, state_msg(me->state)); + me->order.order_key, _state_msg(me->state)); break; - case State::End: + case State::END: if (me->order.cc_order_key == create_order_msg.order_id) LOG(OrderMan, Error, "CCAPISingleOrderManager::handle_create ok: {} state: {}", - me->order.order_key, state_msg(me->state)); + me->order.order_key, _state_msg(me->state)); break; } } -void CCAPISingleOrderManager::handle_order_update( +void CCAPISingleOrderManager::handle_order_sub_update( const CCAPIOrderUpdateMsg &order_update_msg) { if (!_relevent_update(order_update_msg.order_id)) return; @@ -179,31 +180,32 @@ void CCAPISingleOrderManager::handle_order_update( "CCAPISingleOrderManager::handle_order_update ok: {} corr_id: {} " "cc_order_key: {} state: {} order_update_msg.order_id: {}", me->order.order_key, me->order.cc_create_corr_id, me->order.cc_order_key, - state_msg(me->state), order_update_msg.order_id); + _state_msg(me->state), order_update_msg.order_id); switch (me->state) { - case State::WaitingForID: + case State::WAITING_FOR_ID: me->buffered_order_updates.push_back(order_update_msg); break; - case State::Working: + case State::WORKING: if (me->order.cc_order_key != order_update_msg.order_id) return; copy_order_update(me->order, order_update_msg); if (in_terminal_state(me->order.status)) { if (me->fills_accounted()) { - _switch_state(State::End); + _switch_state(State::END); } else { - _switch_state(State::EndWaitingForFills); + _switch_state(State::END_WAITING_FOR_FILLS); } } break; - case State::EndWaitingForFills: + case State::END_WAITING_FOR_FILLS: break; - case State::End: + case State::END: break; } } -void CCAPISingleOrderManager::handle_trade(const CCAPITradeMsg &trade_msg) { +void CCAPISingleOrderManager::handle_trade_sub_update( + const CCAPITradeMsg &trade_msg) { if (!_relevent_update(trade_msg.order_id)) return; LOG(OrderMan, Info, @@ -211,26 +213,26 @@ void CCAPISingleOrderManager::handle_trade(const CCAPITradeMsg &trade_msg) { "cc_order_key: {} state: {} trade_id: {} " "p: {} q: {}", me->order.order_key, me->order.cc_create_corr_id, me->order.cc_order_key, - state_msg(me->state), trade_msg.trade_id, trade_msg.last_exec_price, + _state_msg(me->state), trade_msg.trade_id, trade_msg.last_exec_price, trade_msg.last_exec_qty); switch (me->state) { - case State::WaitingForID: + case State::WAITING_FOR_ID: me->buffered_trades.push_back(trade_msg); break; - case State::Working: + case State::WORKING: if (me->order.cc_order_key != trade_msg.order_id) return; me->accumulated_fills += trade_msg.last_exec_qty; me->order.cb_trades.emplace_back(trade_msg); break; - case State::EndWaitingForFills: + case State::END_WAITING_FOR_FILLS: me->accumulated_fills += trade_msg.last_exec_qty; me->order.cb_trades.emplace_back(trade_msg); if (me->fills_accounted()) { - _switch_state(State::End); + _switch_state(State::END); } break; - case State::End: + case State::END: break; } } @@ -255,21 +257,21 @@ const CCAPIOrderState &CCAPISingleOrderManager::order_state() const { void CCAPISingleOrderManager::_switch_state(State new_state) { LOG(OrderMan, Info, "CCAPISingleOrderManager::_switch_state ok: {} cc_api_key: {} {} -> {}", - me->order.order_key, me->order.cc_order_key, state_msg(me->state), - state_msg(new_state)); + me->order.order_key, me->order.cc_order_key, _state_msg(me->state), + _state_msg(new_state)); me->state = new_state; } -std::string CCAPISingleOrderManager::state_msg( +std::string CCAPISingleOrderManager::_state_msg( CCAPISingleOrderManager::State state) { switch (state) { - case State::WaitingForID: + case State::WAITING_FOR_ID: return "WaitingForID"; - case State::Working: + case State::WORKING: return "Working"; - case State::EndWaitingForFills: + case State::END_WAITING_FOR_FILLS: return "EndWaitingForFills"; - case State::End: + case State::END: return "End"; } bts_assert(false); @@ -278,7 +280,7 @@ std::string CCAPISingleOrderManager::state_msg( bool CCAPISingleOrderManager::_relevent_update( const std::string &cc_ord_key) const { - return me->state == State::WaitingForID || + return me->state == State::WAITING_FOR_ID || me->order.cc_order_key == cc_ord_key; } diff --git a/src/lib/orderman/ccapi/CCAPISingleOrderManager.h b/src/lib/orderman/ccapi/CCAPISingleOrderManager.h index 72e41d320..da22e3346 100644 --- a/src/lib/orderman/ccapi/CCAPISingleOrderManager.h +++ b/src/lib/orderman/ccapi/CCAPISingleOrderManager.h @@ -11,6 +11,8 @@ struct CCAPIOrderUpdateMsg; struct CCAPITradeMsg; struct CCAPIOrderState; +// Handles the state management for a single order. The complexity here +// is that the class CCAPISingleOrderManager { public: @@ -23,18 +25,22 @@ class CCAPISingleOrderManager { double order_qty); ~CCAPISingleOrderManager(); - bool inited() const; - - void handle_create(const CCAPICreateOrderMsg &create_order_msg); - - void handle_order_update(const CCAPIOrderUpdateMsg &order_update_msg); - - void handle_trade(const CCAPITradeMsg &trade_msg); - + // This is a CCAPI standard message in response to a create request. + // This should be the first message + void handle_create_reponse(const CCAPICreateOrderMsg &create_order_msg); + // This is a CCAPI standard subcription message that we receive when we + // subscribe to the instrument orders (CCAPI_EM_ORDER_UPDATE) + void handle_order_sub_update(const CCAPIOrderUpdateMsg &order_update_msg); + // Similiar to above, but trade subscription messages that are + // sent by CCAPI when we subscribe to instrument trades + // (CCAPI_EM_PRIVATE_TRADE) + void handle_trade_sub_update(const CCAPITradeMsg &trade_msg); + // This is essentially a transaction begin. All of the 3 calls above are + // called with a dispatch start / end void dispatch_start(); - - // if there is a change return true + // End of a transaction bool dispatch_end(); + // this is called when an order price / qty is changed by the system void handle_order_update_out(double new_price, double new_qty); const CCAPIOrderState &order_state() const; @@ -44,7 +50,7 @@ class CCAPISingleOrderManager { PImpl *me; enum class State; void _switch_state(State new_state); - std::string state_msg(State new_state); + std::string _state_msg(State new_state); bool _relevent_update(const std::string &cc_ord_key) const; }; diff --git a/src/lib/orderman/ccapi/ICCAPIOrderMux.h b/src/lib/orderman/ccapi/ICCAPIOrderMux.h index e88514292..03aa7b89e 100644 --- a/src/lib/orderman/ccapi/ICCAPIOrderMux.h +++ b/src/lib/orderman/ccapi/ICCAPIOrderMux.h @@ -64,11 +64,11 @@ using OnCCAPIExchangeOpenOrderUpdate = using OnCCAPIOrderUpdate = std::function; +// Every CCAPI execution implemented by us, derives from this. This is managed +// by the CCAPIExecutionGateway(::IExecutionGateway) which is the generic way +// the system interacts with exchange gateways class ICCAPIOrderMux { public: - // System Data - virtual void on_securities( - const bts::mercury::Update &update) = 0; // Orders // ////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////// diff --git a/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp b/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp index a11143c9a..b64359d48 100644 --- a/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp +++ b/src/lib/orderman/gateways/CCAPIExecutionGateway.cpp @@ -5,7 +5,6 @@ #include "lib/core/TimeStamp.h" #include "lib/domain_model/Security.pb.h" #include "lib/domain_model/SecurityKey.h" -//#include "lib/domain_model/common.h" #include "lib/domain_model/common.h" #include "lib/logging/logging.h" #include "lib/md/SecurityOracle.h" @@ -15,6 +14,7 @@ #include "lib/orderman/OrderMsg.h" #include "lib/orderman/RFQMsg.h" #include "lib/orderman/ccapi/CCAPIDeribitOrderMux.h" +#include "lib/orderman/ccapi/ICCAPIOrderMux.h" #include "lib/orderman/events/NewAdminDataEvent.h" #include "lib/orderman/events/NewExecutionReportEvent.h" #include "lib/orderman/events/NewSecuritiesEvent.h" @@ -24,12 +24,9 @@ #include "lib/orderman/orderman_utils/ExecutionReport.h" #include "lib/orderman/orderman_utils/orderman_common.h" #include "lib/os/os.h" -//#include "lib/tracing/bts_trace.h" #include "lib/utils/bts_assert.h" #include "lib/utils/bts_chrono.h" #include "lib/utils/datetime.h" -//#include "lib/utils/helper_macros.h" -#include "lib/orderman/ccapi/ICCAPIOrderMux.h" #include "lib/api/service_helpers/AdminServiceUtils.h" #include "lib/config/config.h" @@ -42,9 +39,8 @@ #include #include //#include -#include -//#include #include "lib/orderman/ccapi/CCAPIConnectionConfig.h" +#include #include #include #include @@ -84,20 +80,50 @@ api::orderman::NativeOrderStatus native_order_status(const CCAPIOrderState &s) { return api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_UNDEFINED; } +struct SingleOrderMux { + ICCAPIOrderMux *order_mux; + std::string account; + uint32_t account_id; +}; + +struct InitState { + enum class StateType { Start = 0, Securities = 1, Admin = 2 }; + map state_map = { + {StateType::Start, false}, + {StateType::Securities, false}, + {StateType::Admin, false}}; + bool set(StateType state) { + bool s0 = inited(); + auto it = state_map.find(state); + bts_assert(it != state_map.end()); + it->second = true; + bool s1 = inited(); + return !s0 && s1; + } + bool inited() const { + for (const auto &kv : state_map) + if (!kv.second) + return false; + return true; + } +}; + struct CCAPIExecutionGateway::PImpl { PImpl(bts::api::Venue venue, md::SecurityOracle o) : venue(venue), sec_oracle(o) { LOG(OrderMan, Info, "CCAPIExecutionGateway::PImpl constructor"); } // TODO: get it from config - std::vector configs = { - CCAPIConnectionConfig{CCAPIConnectionConfig::DeribitConnectionConfig{ - "ZmIKL6fb", "_FY2PcXYNc8VdlfkZO5c-pkFJQFhn8P9z4_p8YA2fS0", "MAIN"}}, - CCAPIConnectionConfig{CCAPIConnectionConfig::DeribitConnectionConfig{ - "v1iSzZrY", "fFOX8SBB2ZKj43xoab2f3YV70DDK5064STWK3WOCrK4", - "SMALL"}}}; - // callback cashed data + std::vector configs = {CCAPIConnectionConfig{ + "MAIN", CCAPIConnectionConfig::DeribitConnectionConfig{ + "ZmIKL6fb", "_FY2PcXYNc8VdlfkZO5c-pkFJQFhn8P9z4_p8YA2fS0"}}}; + // CCAPIConnectionConfig{ + // "SMALL", + // CCAPIConnectionConfig::DeribitConnectionConfig{ + // "v1iSzZrY", "fFOX8SBB2ZKj43xoab2f3YV70DDK5064STWK3WOCrK4"}}}; const bts::api::Venue venue; + InitState init_state = {}; + std::vector mux_vec = {}; const size_t pos_query_period_ms = 10000; core::TimeStamp last_pos_query_time = core::TimeStamp::now(); api::admin::AdminData admin_data = {}; @@ -109,15 +135,12 @@ struct CCAPIExecutionGateway::PImpl { OnExchangePositionState on_exchange_position_state; OnExchangeOpenOrdersState on_exchange_open_orders; // orders are sent out and callbacks received via IEMOrderMuxer - ICCAPIOrderMux *order_mux = nullptr; size_t msg_seq_num = 0; boost::object_pool exe_report_pool; std::unordered_map order_map = {}; // this is updated as we get exchange positions ExchangePosition exchange_position; ExchangeOpenOrders exchange_open_orders; - // periodic query (temporary) - bool inited() const { return order_mux != nullptr; } }; CCAPIExecutionGateway::CCAPIExecutionGateway( @@ -134,23 +157,29 @@ CCAPIExecutionGateway::CCAPIExecutionGateway( CCAPIExecutionGateway::~CCAPIExecutionGateway() {} void CCAPIExecutionGateway::start() { - _init(); LOG(OrderMan, Info, "CCAPIExecutionGateway::start t_id: {} " "t_name: {}", os::get_thread_id(), os::get_thread_name()); + bool just_inited = me->init_state.set(InitState::StateType::Start); + if (just_inited) { + _init(); + } } // this is a periodic timer void CCAPIExecutionGateway::dispatch_incoming_fix_messages() { - if (!me->inited()) + if (!me->init_state.inited()) return; - me->order_mux->dispatch_incoming_messages(); + for (auto &mux : me->mux_vec) + mux.order_mux->dispatch_incoming_messages(); if (core::TimeStamp::now().millis() - me->last_pos_query_time.millis() >= me->pos_query_period_ms) { me->last_pos_query_time = core::TimeStamp::now(); - me->order_mux->query_positions(); - me->order_mux->query_open_orders(); + for (auto &mux : me->mux_vec) { + mux.order_mux->query_positions(); + mux.order_mux->query_open_orders(); + } } } @@ -160,19 +189,24 @@ void CCAPIExecutionGateway::on_securities( "CCAPIExecutionGateway::on_securities t_id: {} t_name: {} n_secs: {}", os::get_thread_id(), os::get_thread_name(), update.events == nullptr ? 0 : update.events->size()); - if (!me->inited()) - return; - me->order_mux->on_securities(update); + bool just_inited = me->init_state.set(InitState::StateType::Securities); + if (just_inited) + _init(); } void CCAPIExecutionGateway::on_admin_data( const mercury::Update &update) { LOG(OrderMan, Info, - "CCAPIExecutionGateway::on_admin_data t_id: {} t_name: {}", - os::get_thread_id(), os::get_thread_name()); - if (update.events) { - for (auto const &ev : *(update.events)) - me->admin_data.CopyFrom(*ev.admin_data); + "CCAPIExecutionGateway::on_admin_data t_id: {} t_name: {} size: {}", + os::get_thread_id(), os::get_thread_name(), + update.events != nullptr ? update.events->size() : 0); + bool has_data = update.events != nullptr && update.events->size() == 1; + if (!has_data) + return; + me->admin_data.CopyFrom(*(update.events)->at(0).admin_data); + bool just_inited = me->init_state.set(InitState::StateType::Admin); + if (just_inited) { + _init(); } } @@ -182,7 +216,7 @@ void CCAPIExecutionGateway::send_fix(const jetfix::OutFIXPtr &, trace::CorID) { void CCAPIExecutionGateway::send_msgs( std::vector const &msg_vec, trace::CorID) { - if (!me->inited()) + if (!me->init_state.inited()) return; LOG(OrderMan, Info, "CCAPIExecutionGateway::send_msgs count: {}", msg_vec.size()); @@ -190,31 +224,56 @@ void CCAPIExecutionGateway::send_msgs( LOG(OrderMan, Info, "CCAPIExecutionGateway::send_msgs {}", m); if (std::holds_alternative(m)) { const CreateOrderMsg &cr_msg = std::get(m); + SingleOrderMux *mux = _find_mux(cr_msg.routing_record); + if (mux == nullptr) { + LOG(OrderMan, Error, + "CCAPIExecutionGateway::send_msgs could not resolve acount for " + "cr: {}", + m); + continue; + } LOG(OrderMan, Info, "CCAPIExecutionGateway::send_msgs Create sec: {} order_key", cr_msg.security->id(), cr_msg.key); me->order_map.insert({cr_msg.key, cr_msg}); - me->order_mux->launch_new_order(cr_msg); + mux->order_mux->launch_new_order(cr_msg); } else if (std::holds_alternative(m)) { const CancelReplaceOrderMsg &cxl_repl_msg = std::get(m); + SingleOrderMux *mux = + _find_mux_from_orderkey(cxl_repl_msg.create_fields.key); + if (mux == nullptr) { + LOG(OrderMan, Error, + "CCAPIExecutionGateway::send_msgs could not resolve acount for " + "cr: {}", + m); + continue; + } LOG(OrderMan, Info, "CCAPIExecutionGateway::send_msgs CancelReplace sec: {} " "order_key: {}", cxl_repl_msg.create_fields.security->id(), cxl_repl_msg.create_fields.key); - me->order_mux->update_order(cxl_repl_msg); + mux->order_mux->update_order(cxl_repl_msg); } else if (std::holds_alternative(m)) { const CancelOrderMsg &cxl_msg = std::get(m); + SingleOrderMux *mux = _find_mux_from_orderkey(cxl_msg.key); + if (mux == nullptr) { + LOG(OrderMan, Error, + "CCAPIExecutionGateway::send_msgs could not resolve acount for " + "cr: {}", + m); + continue; + } LOG(OrderMan, Info, "CCAPIExecutionGateway::send_msgs Cancel order_key: {}", cxl_msg.key); - me->order_mux->cancel_order(cxl_msg); + mux->order_mux->cancel_order(cxl_msg); } else if (std::holds_alternative(m)) { const RFQMsg &rfq_msg = std::get(m); LOG(OrderMan, Info, "CCAPIExecutionGateway::send_msgs RFQ: {}", utils::pb::to_string(rfq_msg.rfq)); - me->order_mux->send_rfq(rfq_msg); + // me->order_mux->send_rfq(rfq_msg); } } } @@ -240,66 +299,29 @@ OnExchangeOpenOrdersState &CCAPIExecutionGateway::on_exchange_open_orders() { } void CCAPIExecutionGateway::_init() { - // TODO: account id - if (me->order_mux != nullptr) - return; + bts_assert(me->init_state.inited()); LOG(OrderMan, Info, "CCAPIExecutionGateway::_init"); - me->order_mux = new CCAPIDeribitOrderMux(me->configs.at(0), me->sec_oracle); - me->order_mux->order_update_cb() = - [this](const CCAPIOrderState &order_state) { - _on_order_cb(order_state); - }; - me->order_mux - ->exchange_position_update_cb() = [this](const std::vector - &pos_vec) { - LOG(OrderMan, Info, "CCAPIExecutionGateway position cb sz: {}", - pos_vec.size()); - ExchangePosition out_pos = {me->venue, {}}; - for (const CCAPIPosition &pos : pos_vec) { - auto sec_ptr = _find_sec(pos.venue, pos.exchange_sec_desc); - if (sec_ptr != nullptr) { - out_pos.total_exchange_positions.push_back( - ExchangePosition::UnitPosition{ - pos.exchange_sec_desc, sec_ptr, pos.internal_account, 9, - pos.position, Price{pos.average_price}}); - } else { - LOG(OrderMan, Error, - "CCAPIExecutionGateway could not resolve exchange: {} desc: {}", - api::Venue_Name(pos.venue), pos.exchange_sec_desc); - } + for (const auto &p : me->configs) { + api::admin::BTSAccount *acct_ptr = admin::AdminServiceUtils::find_account( + me->admin_data, p.internal_account); + if (acct_ptr == nullptr) { + LOG(OrderMan, Error, + "CCAPIExecutionGateway::_init could not resolve account: {}", + p.internal_account); + continue; } - LOG(OrderMan, Info, "CCAPIExecutionGateway firing positions sz: {}", - out_pos.total_exchange_positions.size()); - me->on_exchange_position_state(out_pos); - }; - me->order_mux->exchange_open_orders_update_cb() = - [this](const std::vector &ord_vec) { - LOG(OrderMan, Info, "CCAPIExecutionGateway working_order cb sz: {}", - ord_vec.size()); - ExchangeOpenOrders out_ords = {me->venue, {}}; - for (const auto &ord : ord_vec) { - auto sec_ptr = _find_sec(me->venue, ord.exchange_sec_desc); - if (sec_ptr != nullptr) { - out_ords.all_open_orders.push_back( - ExchangeOpenOrders::UnitOrder{ - ord.exchange_sec_desc, ord.exchange_account, sec_ptr, - ord.exchange_order_id, ord.account_name, 9, ord.tif, - ord.side, Price{ord.price}, - Quantity::create_new(ord.qty), Price{ord.filled_price}, - Quantity::create_new(ord.filled_qty), - ord.creation_timestamp, ord.last_update_timestamp, - !ord.web, ord.web}); - } else { - LOG(OrderMan, Error, - "CCAPIExecutionGateway order callback could not resolve " - "exchange: {} desc: {}", - me->venue, ord.exchange_sec_desc); - } - } - LOG(OrderMan, Info, "CCAPIExecutionGateway firing orders sz: {}", - out_ords.all_open_orders.size()); - me->on_exchange_open_orders(out_ords); - }; + CCAPIDeribitOrderMux *mux = new CCAPIDeribitOrderMux(p, me->sec_oracle); + me->mux_vec.push_back({mux, p.internal_account, acct_ptr->id()}); + mux->order_update_cb() = [this](const CCAPIOrderState &order_state) { + _on_order_cb(order_state); + }; + mux->exchange_position_update_cb() = [this](const auto &pos_vec) { + _on_exchange_positions(pos_vec); + }; + mux->exchange_open_orders_update_cb() = [this](const auto &ord_vec) { + _on_exchange_working_orders(ord_vec); + }; + } } void CCAPIExecutionGateway::_on_order_cb(const CCAPIOrderState &s) { @@ -382,4 +404,88 @@ api::Security const *CCAPIExecutionGateway::_find_sec( return nullptr; } +void CCAPIExecutionGateway::_on_exchange_positions( + const std::vector &pos_vec) { + LOG(OrderMan, Info, + "CCAPIExecutionGateway::_on_exchange_positions cb sz: {}", + pos_vec.size()); + ExchangePosition out_pos = {me->venue, {}}; + for (const CCAPIPosition &pos : pos_vec) { + auto sec_ptr = _find_sec(pos.venue, pos.exchange_sec_desc); + api::admin::BTSAccount *acct_ptr = admin::AdminServiceUtils::find_account( + me->admin_data, pos.internal_account); + if (sec_ptr != nullptr && acct_ptr != nullptr) { + out_pos.total_exchange_positions.push_back( + ExchangePosition::UnitPosition{ + pos.exchange_sec_desc, sec_ptr, pos.internal_account, + acct_ptr->id(), pos.position, Price{pos.average_price}}); + } else { + LOG(OrderMan, Error, + "CCAPIExecutionGateway::_on_exchange_positions could not " + "resolve " + "exchange: {} desc: {} account: {} , this position will not be " + "reported", + api::Venue_Name(pos.venue), pos.exchange_sec_desc, + pos.internal_account); + } + } + LOG(OrderMan, Info, + "CCAPIExecutionGateway::_on_exchange_positions firing positions sz: " + "{}", + out_pos.total_exchange_positions.size()); + me->on_exchange_position_state(out_pos); +} + +void CCAPIExecutionGateway::_on_exchange_working_orders( + const std::vector &ord_vec) { + LOG(OrderMan, Info, + "CCAPIExecutionGateway::_on_exchange_working_orders sz: {}", + ord_vec.size()); + ExchangeOpenOrders out_ords = {me->venue, {}}; + for (const auto &ord : ord_vec) { + auto sec_ptr = _find_sec(me->venue, ord.exchange_sec_desc); + api::admin::BTSAccount *acct_ptr = admin::AdminServiceUtils::find_account( + me->admin_data, ord.account_name); + if (sec_ptr != nullptr && acct_ptr != nullptr) { + out_ords.all_open_orders.push_back(ExchangeOpenOrders::UnitOrder{ + ord.exchange_sec_desc, ord.exchange_account, sec_ptr, + ord.exchange_order_id, ord.account_name, acct_ptr->id(), ord.tif, + ord.side, Price{ord.price}, Quantity::create_new(ord.qty), + Price{ord.filled_price}, Quantity::create_new(ord.filled_qty), + ord.creation_timestamp, ord.last_update_timestamp, !ord.web, + ord.web}); + } else { + LOG(OrderMan, Error, + "CCAPIExecutionGateway::_on_exchange_working_orders could not " + "resolve exchange: {} desc: {} account: {} this order will not be " + "reported", + me->venue, ord.exchange_sec_desc, ord.account_name); + } + } + LOG(OrderMan, Info, + "CCAPIExecutionGateway::_on_exchange_working_orders firing orders " + "sz: " + "{}", + out_ords.all_open_orders.size()); + me->on_exchange_open_orders(out_ords); +} + +SingleOrderMux *CCAPIExecutionGateway::_find_mux( + api::orderman::RoutingRecord const *r) { + if (r == nullptr) + return nullptr; + for (auto &m : me->mux_vec) { + if (m.account == r->account()) + return &m; + } + return nullptr; +} + +SingleOrderMux *CCAPIExecutionGateway::_find_mux_from_orderkey(OrderKey key) { + auto it = me->order_map.find(key); + if (it == me->order_map.end()) + return nullptr; + return _find_mux(it->second.routing_record); +} + } // namespace bts::orderman \ No newline at end of file diff --git a/src/lib/orderman/gateways/CCAPIExecutionGateway.h b/src/lib/orderman/gateways/CCAPIExecutionGateway.h index 3daf3d96a..565e52f2d 100644 --- a/src/lib/orderman/gateways/CCAPIExecutionGateway.h +++ b/src/lib/orderman/gateways/CCAPIExecutionGateway.h @@ -2,12 +2,14 @@ #include "IExecutionGateway.h" #include "lib/api/services/AdminService.pb.h" +#include "lib/api/services/OrderService.pb.h" #include "lib/domain_model/Security.pb.h" #include "lib/orderman/CancelOrderMsg.h" #include "lib/orderman/CancelReplaceOrderMsg.h" #include "lib/orderman/CreateOrderMsg.h" #include "lib/orderman/RFQMsg.h" #include "lib/orderman/ccapi/CCAPIOrderState.h" +#include "lib/orderman/orderman_utils/orderman_common.h" #include "server/sparkd/md/platforms/emumba/IEMOrderMuxer.h" #include #include @@ -22,11 +24,18 @@ // Callbacks are sent back to the OrderManager via the 4 callback functions. +namespace bts::api::orderman { +class RoutingRecord; +} + namespace bts { namespace orderman { class ExecutionReport; struct RFQMsg; +struct CCAPIPosition; +struct CCAPIExchangeOpenOrder; +struct SingleOrderMux; class CCAPIExecutionGateway : public IExecutionGateway { public: @@ -55,6 +64,11 @@ class CCAPIExecutionGateway : public IExecutionGateway { void _on_order_cb(const CCAPIOrderState &); api::Security const *_find_sec( api::Venue venue, const std::string &exchange_desc); + void _on_exchange_positions(const std::vector &); + void _on_exchange_working_orders( + const std::vector &); + SingleOrderMux *_find_mux(api::orderman::RoutingRecord const *); + SingleOrderMux *_find_mux_from_orderkey(OrderKey); }; } // namespace orderman