#include "GLBXNativeOrder.h" #include "lib/api/services/OrderService.pb.h" #include "lib/config/config.h" #include "lib/config/protos/orderman_cfg.pb.h" #include "lib/config/protos/toggles.pb.h" #include "lib/domain_model/Security.h" #include "lib/jetfix/codec/FIXFragment.h" #include "lib/jetfix/codec/FieldDefinitions.h" #include "lib/logging/logging.h" #include "lib/orderman/OrderRouter.h" #include "lib/orderman/actors/order_manager/OrderServices.h" #include "lib/orderman/order_factory/IOrderFactory.h" #include "lib/orderman/orderman_utils/ExecutionReport.h" #include "lib/orderman/orderman_utils/fix_order_codec.h" #include "lib/orderman/orders/PreActivationOrderServices.h" #include "lib/orderman/orders/glbx/IGLBXOrderEncoder.h" #include "lib/orderman/orders/glbx/iLink2OrderEncoder.h" #include "lib/orderman/orders/glbx/iLink3OrderEncoder.h" #include "lib/orderman/securities/ISecurityDB.h" #include "lib/utils/PBUtils.h" #include "lib/utils/bts_chrono.h" #include #include namespace bts { namespace orderman { using namespace api::orderman; OrderStatus map_external_status(NativeOrderStatus); bool use_ilink3(std::string const &for_session) { auto &all_connections = config::get().connection(); for (auto const &c : all_connections) if (for_session == c.name()) return c.use_ilink3(); return false; } struct GLBXNativeOrder::PImpl { PImpl() : services(nullptr), session_services(), sec(nullptr), previous_working_position(0), definition(), state(), price_encoding_precision(7), exchange_order_id() {} OrderServices *services; SessionServices *session_services; const api::Security *sec; std::unique_ptr encoder; Quantity previous_working_position; OrderDefinition definition; OrderState state; int price_encoding_precision; std::optional exchange_order_id; OrderServices::ExeReportSubID exe_report_sid; OrderServices::CancelRejectSubID cancel_reject_sid; bool buffered_cancel = false; std::optional buffered_update; RoutingRecord routing_record; bool stop_order_still_has_stop_px = true; }; GLBXNativeOrder::GLBXNativeOrder() : me(new PImpl()) {} OrderDefinition const &GLBXNativeOrder::definition() const { return me->definition; } void GLBXNativeOrder::on_init_new( OrderDefinition const &def, const PreActivationOrderServices &serv) { // order was just created. me->definition = def; me->sec = serv.sec_db.resolve(SecurityKey(def.security_key())); if (!me->sec) { auto msg = fmt::format("Unknown security: {}", def.security_key()); me->state.set_last_msg(msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } switch (def.custom_def().custom_case()) { case CustomOrderDefinition::kMarket: me->state.mutable_market(); break; case CustomOrderDefinition::kLimit: me->state.mutable_limit(); break; case CustomOrderDefinition::kStop: me->state.mutable_stop(); break; case CustomOrderDefinition::kStopLimit: me->state.mutable_stop_limit(); break; case CustomOrderDefinition::kGlbxIceberg: { me->state.mutable_glbx_iceberg(); auto &ib = def.custom_def().glbx_iceberg(); if (ib.max_show_quantity() == 0 || ib.max_show_quantity() > pow(10, max_show_sz()) - 1) { auto msg = fmt::format("Invalid max show size: {}", ib.max_show_quantity()); me->state.set_last_msg(msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } if (me->sec->exchange() != api::VENUE_GLBX) { auto msg = "Order type not supported in this venue"; me->state.set_last_msg(msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } break; } default: bts_assert(false); break; } auto rq = serv.order_router.get_routing_record( UserID(def.user_id()), AccountID(def.account_id()), *me->sec); if (!rq.has_route) { auto msg = fmt::format("Could not route order: {}", rq.error_msg); LOG(OrderMan, Error, "{}", msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } transition(ORDER_STATUS_INACTIVE); auto &native_state = get_native_state(me->state); fixup_routing_record(&rq.routing_record); me->routing_record = rq.routing_record; *native_state.mutable_routing_record() = rq.routing_record; init_encodings(); } void GLBXNativeOrder::on_init_recovered( OrderRecord const &rec, const PreActivationOrderServices &serv) { // order was recovered from our orders database or from an execution // report auto const &def = rec.def(); me->definition = def; me->state = rec.state(); me->sec = serv.sec_db.resolve(SecurityKey(def.security_key())); me->previous_working_position = Quantity(0); auto &native_state = get_native_state(me->state); switch (me->state.status()) { case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_DISCONNECTED: { // bail if we can't find the security for the order if (!me->sec) { LOG(OrderMan, Error, "Unknown security {} referenced by recovered " "order {}. This is a serious " "problem which has to be corrected manually. ", def.security_key(), rec.key()); transition_to_error( NativeOrderState::SUB_ERROR_UNKNOWN_SECURITY, fmt::format("Unknown security: {}", def.security_key())); return; } auto rq = serv.order_router.get_routing_record( UserID(def.user_id()), AccountID(def.account_id()), *me->sec); if (!rq.has_route) { auto msg = fmt::format("Could not route order: {}", rq.error_msg); LOG(OrderMan, Error, "Unable to route order {} recovered from disk. Message: {}", rec.key(), msg); transition_to_error( NativeOrderState::SUB_ERROR_UNKNOWN_FIX_SESSION, "Could not route order"); return; } // if we made it this far we are good. fixup_routing_record(&rq.routing_record); me->routing_record = rq.routing_record; *native_state.mutable_routing_record() = rq.routing_record; init_encodings(); if (me->state.status() != ORDER_STATUS_PENDING_WORKING) { me->exchange_order_id = get_exchange_order_id(native_state); me->encoder->update_exchange_order_id(me->exchange_order_id.value()); } return; } case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_ERROR: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: // terminal states, nothing to do return; case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); return; } } api::orderman::OrderDefinition GLBXNativeOrder::on_init_from_exe_report( ExecutionReport const &er, const PreActivationOrderServices &os) { auto k = er.order_key; OrderRecord orecord; orecord.set_key(k.value()); orecord.set_parent_key(null_order_key().value()); auto &def = *orecord.mutable_def(); def.set_security_key(er.security->id()); def.set_side(er.side); auto sec = os.sec_db.resolve(SecurityKey(def.security_key())); auto rev_rec = os.order_router.get_reverse_routing_record( er.cfg->name(), to_trim_str(er.operator_id), to_trim_str(er.account_name), sec); if (rev_rec.ok) { LOG(OrderMan, Error, "Successfully recovered order {} from execution report, " "using operator id: {}" " and account: {} on connection: {}. BTS user: {} BTS account: {} ", k.value(), to_trim_str(er.operator_id), to_trim_str(er.account_name), er.cfg->name(), rev_rec.user, rev_rec.account); def.set_user(rev_rec.user); def.set_user_id(rev_rec.user_id.value()); def.set_account(rev_rec.account); def.set_account_id(rev_rec.account_id.value()); } else { LOG(OrderMan, Error, "Could not recover BTS account and user information for order {} " "using operator id: {}" " and account: {} on connection: {}. The order router returned the " "following: ", k.value(), to_trim_str(er.operator_id), to_trim_str(er.account_name), er.cfg->name(), rev_rec.error_msg); def.set_user(""); def.set_user_id(0); def.set_account(""); def.set_account_id(0); } def.set_time_in_force(er.time_in_force); def.set_manual_order_indicator(er.manual_order_indicator); def.set_cti_code(CTICode(er.cfg->cti_code()[0])); def.set_customer_or_firm(CustomerOrFirm(er.cfg->customer_or_firm())); auto &state = *orecord.mutable_state(); state.set_status(map_external_status(er.order_status)); state.set_price(er.price.value()); state.set_quantity(er.quantity.value()); state.set_filled_quantity(er.filled_quantity.value()); state.set_last_price(er.last_price.value()); state.set_avg_price(er.last_price.value()); state.set_last_msg(er.msg); *state.mutable_last_change() = utils::pb::pb_now(); switch (er.order_type) { case NATIVE_ORDER_TYPE_MARKET: def.mutable_custom_def()->mutable_market(); state.mutable_market(); break; case NATIVE_ORDER_TYPE_LIMIT: if (er.max_show.value() == 0) { def.mutable_custom_def()->mutable_limit(); state.mutable_limit(); } else { def.mutable_custom_def()->mutable_glbx_iceberg(); state.mutable_glbx_iceberg(); } break; case NATIVE_ORDER_TYPE_STOP: { auto &stop_def = *def.mutable_custom_def()->mutable_stop(); stop_def.set_stop_price(er.stop_price.value()); state.mutable_stop(); break; } case NATIVE_ORDER_TYPE_STOP_LIMIT: { auto &stop_limit_def = *def.mutable_custom_def()->mutable_stop_limit(); stop_limit_def.set_stop_price(er.stop_price.value()); state.mutable_stop_limit(); break; } case NATIVE_ORDER_TYPE_MARKET_LIMIT: case NATIVE_ORDER_TYPE_UNDEFINED: case NativeOrderType_INT_MIN_SENTINEL_DO_NOT_USE_: case NativeOrderType_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } auto &native_state = get_native_state(state); set_exchange_order_id(er.exchange_order_id, &native_state); native_state.set_last_msg_seq_num(er.msg_seq_num); native_state.set_native_type(er.order_type); native_state.set_stop_px(er.stop_price.value()); auto &rr = *native_state.mutable_routing_record(); rr.set_session(er.cfg->name()); rr.set_account(to_trim_str(er.account_name)); rr.set_operator_id(to_trim_str(er.operator_id)); rr.set_cti_code(CTICode(er.cfg->cti_code()[0])); rr.set_customer_or_firm(CustomerOrFirm(er.cfg->customer_or_firm())); rr.set_location(er.cfg->sender_locationid()); rr.set_cust_order_handling_inst(er.cust_order_handling_inst); fixup_routing_record(&rr); on_init_recovered(orecord, os); return orecord.def(); } GLBXNativeOrder::~GLBXNativeOrder() {} void GLBXNativeOrder::warm_up_activate( OrderServicesData &data, OrderServices &services) { bts_assert(!me->services); me->services = &services; init_order_services(data, services); // save these so we can re-instate them after we are done with the warmup auto before_state = me->state.status(); auto before_msg = me->state.last_msg(); _on_activate(NoLog, NoLog, Price(0), Quantity(0), services); // undo warm up side effects me->state.set_status(before_state); me->state.set_last_msg(before_msg); me->services->unsubscribe_from_exe_report( *me->session_services, me->exe_report_sid); me->services->unsubscribe_from_cancel_reject( *me->session_services, me->cancel_reject_sid); me->services->unsubscribe_from_gateway_status(*me->session_services); me->services = nullptr; } OrderOpResult GLBXNativeOrder::_on_activate( log::Level reject_level, log::Level transition_level, Price p, Quantity q, bts::orderman::OrderServices &order_services) { me->state.set_price(p.value()); me->state.set_quantity(q.value()); me->state.set_filled_quantity(0); me->state.set_last_price(0); me->state.set_avg_price(0); me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session()); me->price_encoding_precision = me->services->price_encoding_precision(*me->session_services); // is our gateway connected? if (!me->services->is_gateway_connected(*me->session_services)) { LOG(OrderMan, reject_level, "Attempt to send order to a disconnected gateway. " "Dropping order {}", key().value()); auto msg = "Exchange gateway is down"; transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult{ORDER_ERROR_GATEWAY_NOT_READY, msg}; } // can we trade? auto lqr = me->services->limiter().can_trade( UserID(me->definition.user_id()), AccountID(me->definition.account_id())); if (!lqr.ok()) { LOG(OrderMan, reject_level, "Unauthorized order attempted. User: {} on " "Account: {}. Msg: {} Order: {}. Dropping order", me->definition.user(), me->definition.account(), lqr.error_msg, key().value()); auto msg = fmt::format("Unauthorized order: {}", lqr.error_msg); transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult{ORDER_ERROR_UNAUTHORIZED, msg}; } // can we trade this security, with this size? lqr = me->services->limiter().can_send_new_order( AccountID(me->definition.account_id()), *me->sec, me->definition.side(), q); if (!lqr.ok()) { LOG(OrderMan, reject_level, "New order would breach limit. User: {} Account: " "{} Msg: {} Order: {}. Dropping order", me->definition.user(), me->definition.account(), lqr.error_msg, key().value()); auto msg = fmt::format("Order would breach limit: {}", lqr.error_msg); transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult{ORDER_ERROR_LIMIT_BREACH, msg}; } // are we under the messaging threshold? if (!me->services->governor(*me->session_services).can_send()) { LOG(OrderMan, reject_level, "New order would cause breach of messaging " "limits. Dropping order {}", key().value()); auto msg = "Messaging threshold breached"; transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg); return OrderOpResult(ORDER_ERROR_MESSAGING_LIMIT_BREACH, msg); } // if we are here we are good. // subscribe to usefull events me->exe_report_sid = me->services->subscribe_to_exe_report( *me->session_services, key(), [this](auto const &r) { this->on_exe_report(r); }); me->cancel_reject_sid = me->services->subscribe_to_cancel_reject( *me->session_services, key(), [this](auto const &cr) { this->on_cancel_reject(cr); }); me->services->subscribe_to_gateway_status( *me->session_services, [this](auto const &gw) { this->on_gateway_status(gw); }); me->encoder->update_create_order_encoding( p, me->price_encoding_precision, q, order_services); return OrderOpResult{}; } OrderOpResult GLBXNativeOrder::on_activate( Price p, Quantity q, bts::orderman::OrderServices &services) { bts_assert(!me->services); me->services = &services; auto result = OrderOpResult{}; switch (me->state.status()) { case ORDER_STATUS_INACTIVE: { // this is a brand new order auto scoped_log = services.log_scope("NativeOrder::on_activate", key().value()); auto corid = services.corid(); auto now = utils::TimeStamp::now(); LOG(Latency, Info, "entry_type:on_activate_1 channel:{} sn:{} app_arrival:{} now:{} " "delta:{}", log::CharPtrWrapper{corid.channel}, corid.sn, corid.app_arrival.to_uint64(), now.to_uint64(), (now - corid.app_arrival).nanoseconds()); result = _on_activate(Warn, Info, p, q, services); if (result.ok()) { LOG(Latency, Info, "entry_type:on_activate_2 channel:{} sn:{} app_arrival:{} now:{} " "delta:{}", log::CharPtrWrapper{corid.channel}, corid.sn, corid.app_arrival.to_uint64(), now.to_uint64(), (now - corid.app_arrival).nanoseconds()); me->encoder->send_create(*me->services, *me->session_services); me->services->governor(*me->session_services).record_sent(); me->state.set_status(ORDER_STATUS_PENDING_WORKING); LOG(OrderMan, Info, "Sent new order with key {} to gateway", key().value()); // Early return so we skip the expensive report_state() // call. It is OK to spkip it because we are bound to report // our state once the excange aknowledges the order. update_working_position(); return OrderOpResult{}; } // When the order fails its limits checks we fall through the // switch to report the error state at the end of this function break; } // all cases below are for orders recovered from disk case ORDER_STATUS_WORKING: me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session()); me->services->subscribe_to_exe_report( *me->session_services, key(), [this](auto const &r) { this->on_exe_report(r); }); me->services->subscribe_to_cancel_reject( *me->session_services, key(), [this](auto const &cr) { this->on_cancel_reject(cr); }); me->services->subscribe_to_gateway_status( *me->session_services, [this](auto const &gw) { this->on_gateway_status(gw); }); if (!me->services->is_gateway_connected(*me->session_services)) { result.error = ORDER_ERROR_GATEWAY_NOT_READY; result.error_msg = "Gateway is disconnected"; transition(ORDER_STATUS_DISCONNECTED); } break; case ORDER_STATUS_DISCONNECTED: me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session()); me->services->subscribe_to_exe_report( *me->session_services, key(), [this](auto const &r) { this->on_exe_report(r); }); me->services->subscribe_to_cancel_reject( *me->session_services, key(), [this](auto const &cr) { this->on_cancel_reject(cr); }); me->services->subscribe_to_gateway_status( *me->session_services, [this](auto const &gw) { this->on_gateway_status(gw); }); if (me->services->is_gateway_connected(*me->session_services)) transition(ORDER_STATUS_WORKING); break; case ORDER_STATUS_PENDING_WORKING: me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session()); me->services->subscribe_to_exe_report( *me->session_services, key(), [this](auto const &r) { this->on_exe_report(r); }); me->services->subscribe_to_cancel_reject( *me->session_services, key(), [this](auto const &cr) { this->on_cancel_reject(cr); }); me->services->subscribe_to_gateway_status( *me->session_services, [this](auto const &gw) { this->on_gateway_status(gw); }); break; case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: break; case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); return result; } OrderOpResult GLBXNativeOrder::on_update(Price p, Quantity q) { api::orderman::Update update; update.set_price(p.value()); update.set_quantity(q.value()); return on_update(update); } OrderOpResult GLBXNativeOrder::on_update(api::orderman::Update const &update) { auto p = Price(update.price()); auto q = Quantity(update.quantity()); auto scoped_log = me->services->log_scope("NativeOrder::on_update", key().value()); auto result = OrderOpResult{}; switch (me->state.status()) { case ORDER_STATUS_WORKING: { auto previous_working_qty = 0; if (me->state.quantity() > me->state.filled_quantity()) previous_working_qty = me->state.quantity() - me->state.filled_quantity(); auto current_working_qty = 0; if (q.value() > me->state.filled_quantity()) current_working_qty = q.value() - me->state.filled_quantity(); auto lqr = me->services->limiter().can_update_order( AccountID(me->definition.account_id()), *me->sec, me->definition.side(), Quantity(previous_working_qty), Quantity(current_working_qty)); // are we under the position limits? if (!lqr.ok()) { auto msg = fmt::format( "Cannot update order due to limit breach: {}", lqr.error_msg); LOG(OrderMan, Error, "Order update failed due to limit breach. Order: {} Msg: {}", key().value(), lqr.error_msg); ignore_or_cancel(msg, ORDER_ERROR_LIMIT_BREACH, &result); break; } // are we under the messaging threshold? if (!me->services->governor(*me->session_services).can_send()) { LOG(OrderMan, Warn, "Cannot update order {} because of messaging limits. ", key().value()); auto msg = "Messaging threshold breached"; ignore_or_cancel(msg, ORDER_ERROR_MESSAGING_LIMIT_BREACH, &result); break; } if (update.has_custom()) { bts_assert( update.custom().custom_case() == me->definition.custom_def().custom_case()); if (update.custom().custom_case() == CustomOrderDefinition::kStop) { // Stop orders do not have prices until they are triggered if (!stop_order_has_been_triggered()) { auto const &stop = update.custom().stop(); auto stop_px = Price(stop.stop_price()); me->definition.mutable_custom_def() ->mutable_stop() ->set_stop_price(stop_px.value()); me->services->report_definition(me->definition); me->encoder->update_cancel_replace_stop_px( stop_px, me->price_encoding_precision); } } else if ( update.custom().custom_case() == CustomOrderDefinition::CustomOrderDefinition::kStopLimit) { if (!stop_order_has_been_triggered()) { auto const &stop_limit = update.custom().stop_limit(); auto stop_px = Price(stop_limit.stop_price()); me->definition.mutable_custom_def() ->mutable_stop_limit() ->set_stop_price(stop_px.value()); me->services->report_definition(me->definition); me->encoder->update_cancel_replace_stop_px( stop_px, me->price_encoding_precision); } } else if ( update.custom().custom_case() == CustomOrderDefinition::kGlbxIceberg) { // GLBX Iceberg auto const &ib = update.custom().glbx_iceberg(); if (ib.max_show_quantity() == 0 || ib.max_show_quantity() > pow(10, max_show_sz()) - 1) { auto msg = fmt::format( "Invalid max show size: {}", ib.max_show_quantity()); ignore_or_cancel(msg, ORDER_ERROR_INVALID_PARAMETER, &result); break; } me->encoder->update_cancel_replace_max_show( Quantity(ib.max_show_quantity())); } } // All good if (is_stop_limit_order() || !is_stop_order() || stop_order_has_been_triggered()) { // Stop orders become limit orders when triggered me->encoder->update_cancel_replace_encoding( p, me->price_encoding_precision, *me->services); } me->encoder->update_cancel_replace_encoding(q, *me->services); me->encoder->send_cancel_replace(*me->services, *me->session_services); me->services->governor(*me->session_services).record_sent(); update_working_position(); if (me->state.last_msg().size()) me->state.set_last_msg(""); // early return so we skip report_state (for speed) return OrderOpResult{}; } case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_PENDING_WORKING: LOG(OrderMan, Warn, "Cannot apply update to order {}. Update: {}@{}. Buffering", key().value(), update.quantity(), update.price()); me->buffered_update.emplace(update); break; case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: break; case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); return result; } OrderOpResult GLBXNativeOrder::on_detach() { return OrderOpResult{}; } void GLBXNativeOrder::on_attached( api::orderman::OrderDefinition const &new_parent) { switch (me->state.status()) { case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_WORKING: { LOG(OrderMan, Info, "Native order {} has been attached to by {}", key().value(), utils::pb::to_string(new_parent)); // Update FIX tags to reflect new parent's information auto rq = me->services->route_order( UserID(new_parent.user_id()), AccountID(new_parent.account_id()), *me->sec); if (!rq.has_route) { auto msg = fmt::format( "Cannot update order routing information: {}", rq.error_msg); transition(me->state.status(), msg); report_state(); return; } auto &native_state = get_native_state(me->state); *native_state.mutable_routing_record() = rq.routing_record; init_encodings(); if (has_exchange_order_id()) me->encoder->update_exchange_order_id(me->exchange_order_id.value()); // Update user, account and manual order indicator based on new parent me->definition.set_manual_order_indicator( api::orderman::ManualOrderIndicator::MANUAL_ORDER_INDICATOR_NO); me->definition.set_user(new_parent.user()); me->definition.set_user_id(new_parent.user_id()); me->definition.set_account(new_parent.account()); me->definition.set_account_id(new_parent.account_id()); me->services->report_definition(me->definition); report_state(); break; } case ORDER_STATUS_CANCELED: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_ERROR: break; case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } } OrderOpResult GLBXNativeOrder::on_cancel() { auto scoped_log = me->services->log_scope("NativeOrder::on_cancel", key().value()); auto result = OrderOpResult{}; switch (me->state.status()) { case ORDER_STATUS_WORKING: { me->encoder->update_cancel_encoding(*me->services); me->encoder->send_cancel(*me->services, *me->session_services); break; } case ORDER_STATUS_CANCELED: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_ERROR: break; case ORDER_STATUS_PENDING_WORKING: { me->buffered_cancel = true; LOG(OrderMan, Warn, "Cannot cancel order {} while in the pending working state. " "Buffering cancel", key().value()); break; } case ORDER_STATUS_DISCONNECTED: { me->buffered_cancel = true; LOG(OrderMan, Warn, "Cannot cancel order {} while in the disconnected state. " "Buffering " "cancel", key().value()); auto msg = "Order will be canceled when re-connected"; result.error = ORDER_ERROR_GATEWAY_NOT_READY; result.error_msg = msg; transition(me->state.status(), msg); break; } case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); return result; } bool GLBXNativeOrder::is_old_exe_report( api::orderman::NativeOrderState &native_state, const NewExecutionReportEvent &er) const { // Do we have a last transact_time ? if (native_state.last_transact_time().size() != sizeof(orderman::ExchangeTimeStampStr) && native_state.last_transact_time_unix_ns() == 0) return false; if (native_state.last_transact_time_unix_ns() == 0) { // No Unix TS transact time, assume we have a text one auto &ts = std::get(er.data->transact_time); if (std::lexicographical_compare( native_state.last_transact_time().begin(), native_state.last_transact_time().end(), ts.value().begin(), ts.value().end())) return false; if (std::equal( native_state.last_transact_time().begin(), native_state.last_transact_time().end(), ts.value().begin(), ts.value().end())) return native_state.last_msg_seq_num() >= er.data->msg_seq_num; return true; } else { // No text based ts we must have a uint64 one auto ts = std::get(er.data->transact_time); if (ts.value() > native_state.last_transact_time_unix_ns()) return false; if (ts.value() < native_state.last_transact_time_unix_ns()) return true; return er.data->msg_seq_num <= native_state.last_msg_seq_num(); } } void GLBXNativeOrder::on_exe_report(const NewExecutionReportEvent &er) { auto scoped_log = me->services->log_scope("NativeOrder::on_exe_report", key().value()); auto &state = me->state; auto &native_state = get_native_state(state); // if we have a previous state we want to ensure this execution // report was not already considered. if (is_old_exe_report(native_state, er)) { LOG(OrderMan, Info, "Ignoring already seen execution report {} in order {}", er.data->msg_seq_num, key().value()); return; } // we do not care about spread leg fills for purposes of order // state maintenance if (er.data->leg_security) { LOG(OrderMan, Diag, "Ignoring leg execution report for order {}", key().value()); return; } native_state.set_last_msg_seq_num(er.data->msg_seq_num); set_last_transact_time(er.data->transact_time, &native_state); auto external_status = map_external_status(er.data->order_status); // filled quantity is reset back to 0 when the order is canceled if (external_status != ORDER_STATUS_CANCELED) { if (er.data->exec_type == api::orderman::EXEC_TYPE_PARTIAL_FILL || er.data->exec_type == api::orderman::EXEC_TYPE_FILL) { bts_assert(er.data->last_shares.value()); auto previous_avg = state.avg_price(); auto previous_sz = state.filled_quantity(); auto fill_price = er.data->last_price.value(); auto fill_sz = er.data->last_shares.value(); auto new_avg = ((previous_avg * previous_sz) + (fill_price * fill_sz)) / (previous_sz + fill_sz); state.set_avg_price(new_avg); state.set_filled_quantity(er.data->filled_quantity.value()); state.set_last_price(er.data->last_price.value()); } } state.set_last_msg(er.data->msg); native_state.set_native_status(er.data->order_status); native_state.set_native_type(er.data->order_type); native_state.set_stop_px(er.data->stop_price.value()); // The FIX message we send for updates has to change once a stop // order is triggered. Post triggering we no longer can update the // stop px. Instead the stop order turns into a regular limit // order, which means we can now update the actual price. if (is_stop_order() && stop_order_has_been_triggered() && me->stop_order_still_has_stop_px) { me->stop_order_still_has_stop_px = false; init_encodings(); } bool got_first_exchange_order_id = !has_exchange_order_id(); if (got_first_exchange_order_id) { me->exchange_order_id = er.data->exchange_order_id; set_exchange_order_id(me->exchange_order_id.value(), &native_state); me->encoder->update_exchange_order_id(me->exchange_order_id.value()); } if (!terminal_state(me->state.status())) { state.set_price(er.data->price.value()); state.set_quantity(er.data->quantity.value()); } switch (me->state.status()) { // terminal states, nothing can change them case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: return; // receiving an execution report does does not mean // we are connected case ORDER_STATUS_DISCONNECTED: break; case ORDER_STATUS_PENDING_WORKING: if (external_status == ORDER_STATUS_WORKING && !me->services->is_gateway_connected(*me->session_services)) transition(ORDER_STATUS_DISCONNECTED); else { transition(external_status); if (external_status == ORDER_STATUS_WORKING) { if (me->buffered_cancel) { LOG(OrderMan, Warn, "Applying buffered cancel to order {}, on first ack", key().value()); on_cancel(); } else if (me->buffered_update.has_value()) { auto update = me->buffered_update.value(); me->buffered_update.reset(); LOG(OrderMan, Warn, "Applying buffered update ({}@{}) to order {}, on " "first ack", update.quantity(), update.price(), key().value()); on_update(update); } } } break; case ORDER_STATUS_WORKING: transition(external_status); break; case ORDER_STATUS_INACTIVE: case ORDER_STATUS_ERROR: case ORDER_STATUS_REJECTED_BY_SPARK: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } report_state(); // we only need the exhange order id and the routing record // reported once, since they are both immutable, so we clear them // after their first report to make subsquent state updates faster if (got_first_exchange_order_id) { native_state.clear_exchange_order_id(); native_state.mutable_routing_record()->Clear(); } } void GLBXNativeOrder::on_cancel_reject(const orderman::CancelRejectEvent &cr) { LOG(OrderMan, Warn, "Cancel reject received for order {}", key().value()); switch (me->state.status()) { case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: break; case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_ERROR: { auto &state = me->state; state.set_last_msg(cr.reject_msg()); report_state(); break; } case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_WORKING: { auto &state = me->state; state.set_last_msg(cr.reject_msg()); if (cr.reason() == CancelRejectReason::UnknownOrder) transition(ORDER_STATUS_CANCELED); report_state(); break; } case ORDER_STATUS_INACTIVE: case ORDER_STATUS_REJECTED_BY_SPARK: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } } void GLBXNativeOrder::on_gateway_status(const GatewayStatusChangeEvent &ev) { if (ev.is_connected) { switch (me->state.status()) { case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_WORKING: break; case ORDER_STATUS_DISCONNECTED: { auto const &native_state = get_native_state(me->state); transition(map_external_status(native_state.native_status())); if (me->state.status() == ORDER_STATUS_WORKING) { if (me->buffered_cancel) { LOG(OrderMan, Warn, "Applying buffered cancel to order {}, on re-connection", key().value()); on_cancel(); } else if (me->buffered_update.has_value()) { auto update = me->buffered_update.value(); me->buffered_update.reset(); LOG(OrderMan, Warn, "Applying buffered update ({}@{}) to order {}, on " "re-connection", update.quantity(), update.price(), key().value()); on_update(update); } } break; } case ORDER_STATUS_INACTIVE: case ORDER_STATUS_REJECTED_BY_SPARK: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } } else { switch (me->state.status()) { case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_PENDING_WORKING: break; case ORDER_STATUS_WORKING: transition(ORDER_STATUS_DISCONNECTED); break; case ORDER_STATUS_INACTIVE: case ORDER_STATUS_REJECTED_BY_SPARK: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } } report_state(); } void GLBXNativeOrder::update_working_position() { if (me->sec) { auto current_position = working_position(); auto previous_position = me->previous_working_position; me->previous_working_position = current_position; if (current_position.value() > previous_position.value()) me->services->limiter().add_to_working_position( *me->sec, AccountID(me->definition.account_id()), me->definition.side(), Quantity(current_position.value() - previous_position.value())); else if (previous_position.value() > current_position.value()) me->services->limiter().remove_from_working_position( *me->sec, AccountID(me->definition.account_id()), me->definition.side(), Quantity(previous_position.value() - current_position.value())); } else LOG(OrderMan, Error, "Order {} ignored for purposes of limit enforcing " "because it references unknown security {} ", key().value(), me->definition.security_key()); } void GLBXNativeOrder::report_state() { update_working_position(); me->services->report_state(me->state); } bool GLBXNativeOrder::is_stop_order() { auto const &def = me->definition; return ( def.custom_def().custom_case() == CustomOrderDefinition::kStop || def.custom_def().custom_case() == CustomOrderDefinition::kStopLimit); } bool GLBXNativeOrder::is_stop_limit_order() { auto const &def = me->definition; return def.custom_def().custom_case() == CustomOrderDefinition::kStopLimit; } bool GLBXNativeOrder::stop_order_has_been_triggered() { if (!is_stop_order()) return false; auto const &native_state = get_native_state(me->state); return has_exchange_order_id() && native_state.native_type() == NATIVE_ORDER_TYPE_LIMIT; } OrderStatus map_external_status(NativeOrderStatus status) { switch (status) { case NATIVE_ORDER_STATUS_NEW: case NATIVE_ORDER_STATUS_PENDING_NEW: case NATIVE_ORDER_STATUS_PARTIALLY_FILLED: case NATIVE_ORDER_STATUS_REPLACED: case NATIVE_ORDER_STATUS_PENDING_CANCEL: case NATIVE_ORDER_STATUS_STOPPED: case NATIVE_ORDER_STATUS_SUSPENDED: case NATIVE_ORDER_STATUS_CANCEL_ACK: case NATIVE_ORDER_STATUS_ACCEPTED_FOR_BIDDING: case NATIVE_ORDER_STATUS_PENDING_REPLACE: case NATIVE_ORDER_STATUS_CALCULATED: return ORDER_STATUS_WORKING; case NATIVE_ORDER_STATUS_FILLED: return ORDER_STATUS_COMPLETED; case NATIVE_ORDER_STATUS_EXPIRED: case NATIVE_ORDER_STATUS_CANCELED: case NATIVE_ORDER_STATUS_REJECTED: case NATIVE_ORDER_STATUS_DONE: case NATIVE_ORDER_STATUS_ORDER_NOT_FOUND: return ORDER_STATUS_CANCELED; case NATIVE_ORDER_STATUS_UNDEFINED: return ORDER_STATUS_ERROR; case NATIVE_ORDER_STATUS_UNACKNOWLEDGED: case NativeOrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case NativeOrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); return ORDER_STATUS_ERROR; } return ORDER_STATUS_ERROR; } bool GLBXNativeOrder::has_exchange_order_id() { return me->exchange_order_id.has_value(); } void GLBXNativeOrder::transition( api::orderman::OrderStatus new_status, std::string const &msg) { transition(Info, new_status, msg); } void GLBXNativeOrder::transition( log::Level level, api::orderman::OrderStatus new_status, std::string const &msg) { auto const &from = OrderStatus_Name(me->state.status()); auto const &to = OrderStatus_Name(new_status); if (from != to) LOG(OrderMan, level, "Transitioning order {} from {} to {}. Msg: {}", key().value(), from, to, msg); me->state.set_status(new_status); me->state.set_last_msg(msg); } void GLBXNativeOrder::transition(api::orderman::OrderStatus new_status) { auto const &from = OrderStatus_Name(me->state.status()); auto const &to = OrderStatus_Name(new_status); if (from != to) LOG(OrderMan, Info, "Transitioning order {} from {} to {}", key().value(), from, to); else LOG(OrderMan, Diag, "Transitioning order {} from {} to {}", key().value(), from, to); me->state.set_status(new_status); } void GLBXNativeOrder::transition_to_error( api::orderman::NativeOrderState::SubError sub_error, std::string const &msg) { me->state.mutable_limit()->mutable_native_state()->set_sub_error_code( sub_error); transition(ORDER_STATUS_ERROR, msg); } Quantity GLBXNativeOrder::working_position() { switch (me->state.status()) { case ORDER_STATUS_WORKING: case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_DISCONNECTED: if (me->state.quantity() > me->state.filled_quantity()) return Quantity(me->state.quantity() - me->state.filled_quantity()); else return Quantity(0); case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_ERROR: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: return Quantity(0); case ORDER_STATUS_INACTIVE: case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); return Quantity(0); } bts_assert(false); return Quantity(0); } bool GLBXNativeOrder::terminal_state(api::orderman::OrderStatus status) const { switch (status) { case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: case ORDER_STATUS_REJECTED_BY_SPARK: return true; case ORDER_STATUS_DISCONNECTED: case ORDER_STATUS_PENDING_WORKING: case ORDER_STATUS_WORKING: return false; case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: case ORDER_STATUS_INACTIVE: bts_assert(false); return false; break; } bts_assert(false); return false; } api::orderman::NativeOrderState & GLBXNativeOrder::get_native_state(api::orderman::OrderState &st) { switch (st.custom_case()) { case OrderState::kMarket: return *st.mutable_market()->mutable_native_state(); case OrderState::kLimit: return *st.mutable_limit()->mutable_native_state(); case OrderState::kStop: return *st.mutable_stop()->mutable_native_state(); case OrderState::kStopLimit: return *st.mutable_stop_limit()->mutable_native_state(); case OrderState::kGlbxIceberg: return *st.mutable_glbx_iceberg()->mutable_native_state(); default: break; } // just to appease compiler bts_assert(false); return *st.mutable_stop_limit()->mutable_native_state(); } void GLBXNativeOrder::ignore_or_cancel( std::string const &msg, api::orderman::OrderError error, OrderOpResult *out) { if (parent_key() == null_order_key()) transition(me->state.status(), msg); else { me->state.set_last_msg(msg); on_cancel(); } *out = {error, msg}; } void GLBXNativeOrder::init_encodings() { auto rr = get_native_state(me->state).routing_record(); if (use_ilink3(rr.session())) me->encoder = std::make_unique(); else me->encoder = std::make_unique(); me->encoder->init( key(), rr, *me->sec, definition(), me->price_encoding_precision, stop_order_has_been_triggered()); } // We need this because at the moment (Jul 2020) the sender_compid and // the CustOrderHandlingInst are not being retrieved from the admin // database for CME. Its quicker to patch the routing record here than // it is to add new fields to the web UI. void GLBXNativeOrder::fixup_routing_record(api::orderman::RoutingRecord *rr) { auto &all_connections = config::get().connection(); for (auto const &c : all_connections) if (c.name() == rr->session()) { rr->set_sender_compid(c.sender_compid()); break; } if (rr->cust_order_handling_inst().empty()) rr->set_cust_order_handing_inst(config::get() .fallback_cust_order_handling_inst()); } } // namespace orderman } // namespace bts