#include "NativeOrderMan.h" #include "lib/api/services/OrderService.pb.h" #include "lib/logging/logging.h" #include "lib/utils/PBUtils.h" #include "lib/logging/logging.h" #include "lib/domain_model/Security.h" #include "server/sparkd/orderman/events/NativeOrderStateChange.h" #include "server/sparkd/orderman/native_orders/NativeOrder.h" #include "server/sparkd/orderman/utils/orderman_utils.h" #include "server/sparkd/securities/SecurityDB.h" #include "server/sparkd/orderman/events/OutGatewayMsg.h" #include "server/sparkd/orderman/events/CreateNativeOrder.h" #include "server/sparkd/orderman/events/UpdateNativeOrder.h" #include "server/sparkd/orderman/events/CancelNativeOrder.h" #include "server/sparkd/orderman/events/GatewayStatusChange.h" #include "server/sparkd/orderman/events/ExecutionReport.h" #include "server/sparkd/orderman/events/TimeChange.h" #include "server/sparkd/orderman/events/CancelReject.h" #include "server/sparkd/jetfix/common/OutFIX.h" #include "lib/utils/datetime.h" #include namespace bts { namespace orderman { using OrderMap = boost::container::flat_map; enum class NativeOrderMan::State {REPLAY,DISCONNECTED,CONNECTED}; struct NativeOrderMan::PImpl { PImpl(securities::SecurityDB &sec_db, config::JetFIX::Connection const&jf_cfg, Observer &obs) : obs(obs), state(State::REPLAY), latest_timestamp(to (datetime::FIX_timestamp(datetime::now()))), order_map(), sec_db(sec_db), free_buffers(), jf_cfg(jf_cfg) {} Observer &obs; State state; OrderTimeStamp latest_timestamp; OrderMap order_map; securities::SecurityDB &sec_db; std::vector free_buffers; config::JetFIX::Connection jf_cfg; }; NativeOrderMan::NativeOrderMan (securities::SecurityDB &sec_db, std::vector const &existing_orders, config::JetFIX::Connection const&gw_connection, Observer &obs) : me (new PImpl(sec_db,gw_connection,obs)) { for (auto const &os : existing_orders) if (os.has_native()) { auto &native_state = os.native(); auto sk = SecurityKey(native_state.security_key()); auto sec = me->sec_db.resolve(sk); if (sec) me->order_map[OrderKey(os.order_key())] = std::make_unique (*sec,OrderKey(os.order_key()),native_state); else { LOG(OrderMan,Error, "Cannot resolve security key {} in stored order {}. This is a serious problem. " "This order will be ignored. Order details are: {}", sk.value(),os.order_key(),utils::pb::to_string(os)); } } pre_allocate_buffers(); } void NativeOrderMan::on(grid::event::Init const&) { LOG(OrderMan,Diag, "NativeOrderMan init"); bts_assert(me->state == State::REPLAY); for (auto const &kvp : me->order_map) { auto const &order = *kvp.second; me->obs.on(event::NativeOrderStateChange {&order.header(),order._state}); } } void NativeOrderMan::on(event::CreateNativeOrder const&create) { auto &order = *create.order; auto k = order.key(); LOG(OrderMan,Diag, "NativeOrderMan CreateNativeOrder {}",k.value()); auto &order_ptr = me->order_map[k]; if (order_ptr) { LOG(OrderMan,Error, "Someone tried to create a native order " "using existing id {}. Order was for security: {}" " This is a dangerous bug" , k.value(), securities::descriptor(*order._header.security)); return; } order_ptr.reset(&order); switch (me->state) { case State::REPLAY: case State::DISCONNECTED: order.mark_rejected_by_spark("Could not connect to the order gateway"); break; case State::CONNECTED: order.set_status (api::orderman::OS_UNACKNOWLEDGED); auto buffer = get_fix_bufer(); order.encode_create(me->latest_timestamp,create.price,create.quantity,&buffer->fix[0]); me->obs.on(event::OutGatewayMsg {buffer}); break; } me->obs.on(event::NativeOrderStateChange {&order.header(),order.state()}); } void NativeOrderMan::on(event::UpdateNativeOrder const&update) { auto &order = *update.order; LOG(OrderMan,Diag, "NativeOrderMan UpdateNativeOrder {}",order.key().value()); auto buffer = get_fix_bufer(); order.encode_update(me->latest_timestamp,update.price,update.quantity,&buffer->fix[0]); me->obs.on(event::OutGatewayMsg {buffer}); } void NativeOrderMan::on(event::CancelNativeOrder const&cancel) { auto &order = *cancel.order; LOG(OrderMan,Diag, "NativeOrderMan CancelNativeOrder {}",order.key().value()); auto buffer = get_fix_bufer(); order.encode_cancel(me->latest_timestamp,&buffer->fix[0]); me->obs.on(event::OutGatewayMsg {buffer}); } void NativeOrderMan::on(event::GatewayStatusChange const&status) { LOG(OrderMan,Diag, "NativeOrderMan GatewayStatusChange {}",status.is_connected); if (status.is_connected) { switch (me->state) { case State::REPLAY: case State::CONNECTED: bts_assert(false); break; case State::DISCONNECTED: transition(State::CONNECTED); break; } } else { switch (me->state) { case State::REPLAY: case State::DISCONNECTED: bts_assert(false); break; case State::CONNECTED: transition(State::DISCONNECTED); break; } } } void NativeOrderMan::on(event::GatewayBeginReplay const&) { LOG(OrderMan,Diag, "NativeOrderMan GatewayBeginReplay"); bts_assert(me->state == State::REPLAY); } void NativeOrderMan::on(event::GatewayEndReplay const&) { LOG(OrderMan,Diag, "NativeOrderMan GatewayEndReplay"); bts_assert(me->state == State::REPLAY); transition(State::DISCONNECTED); } void NativeOrderMan::on(event::ExecutionReport const&er) { auto k = er.order_key; LOG(OrderMan,Diag, "NativeOrderMan ExecutionReport for order {}",k.value()); auto &order_ptr = me->order_map[k]; if (order_ptr) order_ptr->on(er); else { LOG(OrderMan,Error, "Received an execution report for an unknown order with key {} " ". Order state will be recovered from this report but fields " "CustomerOrFirm and CTI code cannot be recovered and will be set " "to the gateway's default values", k.value()); api::orderman::NativeOrderState recovered; recovered.set_account_name(to_str(er.account_name)); recovered.set_operator_id(to_str(er.operator_id)); recovered.set_security_key(er.security->id()); recovered.set_side(er.side); recovered.set_time_in_force(er.time_in_force); recovered.set_order_type(er.order_type); recovered.set_customer_or_firm(api::orderman::CustomerOrFirm(me->jf_cfg.customer_or_firm())); recovered.set_cti_code (api::orderman::CTICode(me->jf_cfg.cti_code()[0])); recovered.set_exchange_order_id(to_str(er.exchange_order_id)); recovered.set_manual_order_indicator(er.manual_order_indicator); recovered.set_price(er.price.value()); recovered.set_order_quantity(er.order_quantity.value()); recovered.set_order_status(er.order_status); recovered.set_avg_price(er.avg_price.value()); recovered.set_filled_quantity(er.filled_quantity.value()); recovered.set_reject_msg(er.reject_msg); order_ptr = std::make_unique(*er.security,k,recovered); } me->obs.on(event::NativeOrderStateChange {&order_ptr->header(),order_ptr->state()}); } void NativeOrderMan::on(event::CancelReject const&cr) { auto k = cr.order_key; LOG(OrderMan,Diag, "NativeOrderMan CancelReject for order {}",k.value()); auto &order_ptr = me->order_map[k]; if (order_ptr) { order_ptr->set_reject_msg(cr.reject_msg); me->obs.on(event::NativeOrderStateChange {&order_ptr->header(),order_ptr->state()}); } else LOG(OrderMan,Error, "Received a cancel reject for an unknown order with key {} " "This should not happen and should be investigated", k.value()); } void NativeOrderMan::on(event::TimeChange const&new_time) { me->latest_timestamp = new_time.ts_str ; pre_allocate_buffers(); } void NativeOrderMan::pre_allocate_buffers() { while (me->free_buffers.size() != 1000) me->free_buffers.push_back(std::make_shared(me->jf_cfg)); } jetfix::OutFIXPtr NativeOrderMan::get_fix_bufer() { if (me->free_buffers.empty()) pre_allocate_buffers(); auto back = me->free_buffers.back(); me->free_buffers.resize(me->free_buffers.size()-1); return back; } const char* NativeOrderMan::state_name(State state) { switch (state) { case State::REPLAY: return "REPLAY"; case State::CONNECTED: return "CONNECTED"; case State::DISCONNECTED: return "DISCONNECTED"; } return nullptr; } void NativeOrderMan::transition(State new_state) { LOG(OrderMan,Info,"Transitioning NativeOrderMan from {} to {}", state_name(me->state),state_name(new_state)); } }}