Files
spark/src/lib/orderman/orders/EMNativeOrder.cpp
T

924 lines
33 KiB
C++

#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 <algorithm>
#include <bits/stdint-uintn.h>
#include <string>
#include <sys/time.h>
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<ExchangeOrderIDVar> exchange_order_id;
OrderServices::ExeReportSubID exe_report_sid;
OrderServices::CancelRejectSubID cancel_reject_sid;
bool buffered_cancel = false;
std::optional<api::orderman::Update> 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<orderman::ExchangeTimeStampStr>(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