#include "EMNativeOrder.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/domain_model/common.h" #include "lib/jetfix/codec/FIXFragment.h" #include "lib/jetfix/codec/FieldDefinitions.h" #include "lib/logging/logging.h" #include "lib/orderman/CancelOrderMsg.h" #include "lib/orderman/CancelReplaceOrderMsg.h" #include "lib/orderman/CreateOrderMsg.h" #include "lib/orderman/OrderRouter.h" #include "lib/orderman/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/OrderOpResult.h" #include "lib/orderman/orders/PreActivationOrderServices.h" #include "lib/orderman/orders/algo/IAlgoOrder.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/os/os.h" #include "lib/utils/PBUtils.h" #include "lib/utils/bts_assert.h" #include "lib/utils/bts_chrono.h" #include "server/sparkd/md/platforms/emumba/EmMDListener.h" #include #include #include #include namespace bts { namespace orderman { using namespace api::orderman; // TODO: move it to a common location OrderStatus em_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; } struct EMNativeOrder::PImpl { PImpl() : services(nullptr), session_services(), sec(nullptr), previous_working_position(0), definition(), state(), exchange_order_id() {} bool inited = false; OrderServices *services; SessionServices *session_services; const api::Security *sec; Quantity previous_working_position; OrderDefinition definition; OrderState state; 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; }; EMNativeOrder::EMNativeOrder() : me(new PImpl()) { LOG(OrderMan, Info, "EMNativeOrder::EMNativeOrder t_id: {} t_name: {}", os::get_thread_id(), os::get_application_name()); } EMNativeOrder::~EMNativeOrder() {} api::orderman::OrderDefinition const &EMNativeOrder::definition() const { return me->definition; } // Construction, the order is not yet live and it may never // be. This can be slow. This is the first call void EMNativeOrder::on_init_new( api::orderman::OrderDefinition const &def, const PreActivationOrderServices &serv) { bts_assert(!me->inited); me->inited = true; LOG(OrderMan, Info, "EMNativeOrder::on_init_new key: {} sec_key: {} user: {} account: {}", key(), def.security_key(), def.user(), def.account()); me->definition = def; me->sec = serv.sec_db.resolve(SecurityKey(def.security_key())); // Check for invariants, if not met, reject the order // 1. Sec can be resolved // 2. Order is either Limit or Market // 3. Routing Record can be constructed (serv.order_router.get_routing_record // returns a valid record) // Else, transition to ORDER_STATUS_INACTIVE, and set native strate 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; default: { auto msg = "Order type not supported at this venue"; me->state.set_last_msg("Order type not supported at this venue"); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); 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, "{}", msg); transition(ORDER_STATUS_REJECTED_BY_SPARK, msg); return; } // Successful order always starts in ORDER_STATUS_INACTIVE transition(ORDER_STATUS_INACTIVE); auto &native_state = get_native_state(me->state); me->routing_record = rq.routing_record; *native_state.mutable_routing_record() = rq.routing_record; LOG(OrderMan, Info, "EMNativeOrder::on_init_new key: {} routing_record: {}", key(), utils::pb::to_string(me->routing_record)); } void EMNativeOrder::on_init_recovered( api::orderman::OrderRecord const &rec, const PreActivationOrderServices &serv) { bts_assert(!me->inited); me->inited = true; 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); LOG(OrderMan, Info, "EMNativeOrder::on_init_recovered key: {} t_id: {} t_name: {}", key(), os::get_thread_id(), os::get_application_name()); transition( OrderStatus::ORDER_STATUS_ERROR, "Recovered Orders are not handled"); } OrderOpResult EMNativeOrder::on_activate( Price p, Quantity q, OrderServices &services) { bts_assert(me->inited); LOG(OrderMan, Info, "EMNativeOrder::on_activate key: {} p: {} q: {}", key(), p, q); bts_assert(!me->services); me->services = &services; auto result = OrderOpResult{}; switch (me->state.status()) { case ORDER_STATUS_INACTIVE: { // this is a brand new order // _on_activate sets the price, quantity result = _on_activate(Warn, Info, p, q, services); if (result.ok()) { CreateOrderMsg c_msg = {}; _create_create_msg(c_msg); transition(ORDER_STATUS_PENDING_WORKING); me->services->queue_order_msg(*me->session_services, c_msg); me->services->governor(*me->session_services).record_sent(); LOG(OrderMan, Info, "EMNativeOrder::on_activate sent new order with key {} to " "gateway", key().value()); // Early return so we skip the expensive report_state() // call. It is OK to skip it because we are bound to report // our state once the excange acknowledges the order. update_working_position(); return OrderOpResult{}; } else { report_state(); return result; } } // control will only reach here if on_init_new failed, or it was a recocered // order, in which case we are already in a terminal state, hence nothing to default: break; } report_state(); return result; } OrderOpResult EMNativeOrder::on_update(Price p, Quantity q) { LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} p: {} q: {}", key().value(), p, q); api::orderman::Update update; update.set_price(p.value()); update.set_quantity(q.value()); return on_update(update); } OrderOpResult EMNativeOrder::on_update(api::orderman::Update const &update) { LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} update: {}", key().value(), utils::pb::to_string(update)); auto new_p = Price(update.price()); auto new_q = Quantity(update.quantity()); LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} p: {} q: {}", key().value(), new_p, new_q); auto result = OrderOpResult{}; // the only state where we consider an update is ORDER_STATUS_WORKING switch (me->state.status()) { case ORDER_STATUS_WORKING: { auto curr_working_qty = _working_qty(); auto potential_working_qty = 0; if (new_q.value() > me->state.filled_quantity()) potential_working_qty = new_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(curr_working_qty), Quantity(potential_working_qty)); lqr.result = Limiter::OK; // 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; } CancelReplaceOrderMsg cxl_repl_msg = {}; _create_create_msg(cxl_repl_msg.create_fields); cxl_repl_msg.create_fields.price = new_p; cxl_repl_msg.create_fields.quantity = new_q; me->services->queue_order_msg(*me->session_services, cxl_repl_msg); 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) (an execution report // should take care of it?) return OrderOpResult{}; } // the 2 other working states 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; // terminal states, nothing to do 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 EMNativeOrder::on_detach() { return {}; } OrderOpResult EMNativeOrder::on_cancel() { LOG(OrderMan, Info, "EMNativeOrder::on_cancel key: {}", key()); auto result = OrderOpResult{}; switch (me->state.status()) { // the only state where a cancel is sent out case ORDER_STATUS_WORKING: { // TODO, CancelOrderMsg is not completely filled CancelOrderMsg cxl_msg = {}; cxl_msg.key = key(); LOG(OrderMan, Info, "EMNativeOrder queue_order_msg for cxl"); me->services->queue_order_msg(*me->session_services, cxl_msg); break; } // already in a terminal state, nothing to do case ORDER_STATUS_CANCELED: case ORDER_STATUS_REJECTED_BY_SPARK: case ORDER_STATUS_COMPLETED: case ORDER_STATUS_ERROR: break; case ORDER_STATUS_PENDING_WORKING: { // we buffer this, and as soon as we get the exchnage id, we cxl it 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; // to print the message 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; } void EMNativeOrder::on_attached(api::orderman::OrderDefinition const &) { // TODO } api::orderman::OrderDefinition EMNativeOrder::on_init_from_exe_report( ExecutionReport const &, const PreActivationOrderServices &) { // TODO return me->definition; } void EMNativeOrder::warm_up_activate(OrderServicesData &, OrderServices &) {} void EMNativeOrder::transition( api::orderman::OrderStatus new_status, std::string const &msg) { transition(Info, new_status, msg); } void EMNativeOrder::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 EMNativeOrder::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 EMNativeOrder::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); } void EMNativeOrder::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()); } // Returns the open position for a working order. If there are fills, // returns the difference Quantity EMNativeOrder::working_position() { switch (me->state.status()) { // working 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); // terminal 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); } void EMNativeOrder::report_state() { update_working_position(); me->services->report_state(me->state); } OrderOpResult EMNativeOrder::_on_activate( log::Level reject_level, log::Level transition_level, Price p, Quantity q, bts::orderman::OrderServices & /*order_services*/) { // update state wrt price, qty, fills 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()); // TODO: just to get going me->session_services = &me->services->get_session_services("sim"); // Checks for the following: // 1. Gateway connection // 2. Risk (can_trade, clip, position) // 3. Governor (orders/sec) // If any of the above fail, it goes to terminal state // (ORDER_STATUS_REJECTED_BY_SPARK) abd returns error // Else, subscribes to service events (including execution report) if (!_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}; } // this is to skip risk limits for options bool turn_risk_off = me->sec->has_option() || me->sec->has_future(); // the following consults the limiter // can the user trade ? auto lqr = me->services->limiter().can_trade( UserID(me->definition.user_id()), AccountID(me->definition.account_id())); if (turn_risk_off) { lqr.result = Limiter::LimiterErrorCode::OK; } 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}; } // risk limits (clip size, position) lqr = me->services->limiter().can_send_new_order( AccountID(me->definition.account_id()), *me->sec, me->definition.side(), q); if (turn_risk_off) { lqr.result = Limiter::LimiterErrorCode::OK; } 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? (governor limits) 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); } // subscribe to usefull events // TODO 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); }); LOG(OrderMan, Info, "EMNativeOrder::_on_activate sucessful key: {}", key()); return OrderOpResult{}; } // OrderState's CustomOrderState has some OrderStates' corresponding to // NativeOrder (ex MarketOrderState, LimitOrderState etc). Each of these special // OrderStates have NativeOrderState - this function plucks that out api::orderman::NativeOrderState &EMNativeOrder::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(); default: break; } bts_assert(false); return *st.mutable_limit()->mutable_native_state(); } NativeOrderType get_native_ord_type(const OrderDefinition &def) { switch (def.custom_def().custom_case()) { case CustomOrderDefinition::kMarket: return NativeOrderType::NATIVE_ORDER_TYPE_MARKET; break; case CustomOrderDefinition::kLimit: return NativeOrderType::NATIVE_ORDER_TYPE_LIMIT; break; default: break; } bts_assert(false); return api::orderman::NATIVE_ORDER_TYPE_LIMIT; } void EMNativeOrder::_create_create_msg(CreateOrderMsg &c) { c.key = key(); c.price = Price(me->state.price()); c.quantity = Quantity(me->state.quantity()); c.security = me->sec; c.side = me->definition.side(); c.order_type = get_native_ord_type(me->definition); c.time_in_force = me->definition.time_in_force(); c.order_type = api::orderman::NATIVE_ORDER_TYPE_LIMIT; c.manual_order_indicator = me->definition.manual_order_indicator(); c.routing_record = &me->routing_record; } // void EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) { // LOG(OrderMan, Info, "EMNativeOrder::_on_exe_report key: {} er: {}", key(), // er.data->to_string()); // 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. // // TODO, just id the report in EMEG // 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 = em_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. // // TODO: stop order // // 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 (!is_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 && // !_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 EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) { LOG(OrderMan, Info, "EMNativeOrder::_on_exe_report key: {} er: {}", key(), er.data->to_string()); auto &state = me->state; auto &native_state = get_native_state(state); 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 = em_map_external_status(er.data->order_status); 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); switch (me->state.status()) { case api::orderman::ORDER_STATUS_INACTIVE: // as soon an order is sent we get leave this state, so there is no way we // should get an er while in this state bts_assert(false); break; // terminal state already, nothing to do case ORDER_STATUS_COMPLETED: case ORDER_STATUS_CANCELED: case ORDER_STATUS_ERROR: LOG(OrderMan, Error, "Received er: {} for key: {} while in terminal state", er.data->to_string(), key()); break; // receiving an execution report does does not mean // we are connected case api::orderman::ORDER_STATUS_WORKING: me->state.set_price(er.data->price.value()); me->state.set_quantity(er.data->quantity.value()); _absorb_fill(*er.data); // this is where most of the action happens transition(external_status); break; case ORDER_STATUS_DISCONNECTED: // we only get out of this state via gw's connected event (not thorugh an // order) break; case ORDER_STATUS_PENDING_WORKING: if (external_status == ORDER_STATUS_WORKING && !_is_gateway_connected(me->session_services)) transition(ORDER_STATUS_DISCONNECTED); else { transition(external_status); // deal with buffered operations 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_REJECTED_BY_SPARK: // it only gets rejected before the order is sent, so similiar to // inactive, we should never get an er here case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_: case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_: bts_assert(false); break; } LOG(OrderMan, Info, "EMNativeOrder::_on_exe_report calling report_state key: {} p: {} q: {}", key(), me->state.price(), me->state.quantity()); report_state(); } bool EMNativeOrder::_is_old_exe_report( api::orderman::NativeOrderState &native_state, const NewExecutionReportEvent &er) const { if (native_state.last_transact_time().size() != sizeof(orderman::ExchangeTimeStampStr)) return false; 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; } bool EMNativeOrder::is_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; } bool EMNativeOrder::_is_gateway_connected(SessionServices *) const { return true; } void EMNativeOrder::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}; } Quantity EMNativeOrder::_working_qty() const { auto rv = Quantity(0); if (me->state.quantity() > me->state.filled_quantity()) { rv = Quantity(me->state.quantity() - me->state.filled_quantity()); } return rv; } void EMNativeOrder::_absorb_fill(const ExecutionReport &er) { if (me->state.filled_quantity() < er.filled_quantity.value()) { // new fills uint32_t last_fills = er.filled_quantity.value() - me->state.filled_quantity(); double last_price = er.avg_price.value() * er.filled_quantity.value() - me->state.avg_price() * me->state.filled_quantity(); last_price /= last_fills; me->state.set_avg_price(er.avg_price.value()); me->state.set_filled_quantity(er.filled_quantity.value()); me->state.set_last_price(last_price); } } } // namespace orderman } // namespace bts