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

1395 lines
48 KiB
C++

#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/domain_model/Security.pb.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/OrderRouter.h"
#include "lib/orderman/OrderServices.h"
#include "lib/orderman/gateways/sim/SimExecutionGatewayFactory.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 <algorithm>
#include <sys/time.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
using std::string;
OrderStatus map_external_status(NativeOrderStatus);
bool use_ilink3(std::string const &for_session) {
auto &all_connections = config::get<config::JetFIX>().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<IGLBXOrderEncoder> encoder;
Quantity previous_working_position;
OrderDefinition definition;
OrderState state;
int price_encoding_precision;
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;
bool stop_order_still_has_stop_px = true;
const bool in_sim_mode =
SimExecutionGatewayFactory::is_sim_execution_on(api::VENUE_GLBX);
};
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:{}",
string{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:{}",
string{corid.channel}, corid.sn, corid.app_arrival.to_uint64(),
now.to_uint64(), (now - corid.app_arrival).nanoseconds());
// in sim mode, we dont need this,
me->encoder->send_create(*me->services, *me->session_services);
if (me->in_sim_mode) {
CreateOrderMsg c_msg = {};
_create_create_msg(c_msg);
me->services->queue_order_msg(*me->session_services, c_msg);
}
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 send_update_in_sim_mode = [&]() {
if (me->in_sim_mode) {
CancelReplaceOrderMsg cxl_repl_msg = {};
_create_create_msg(cxl_repl_msg.create_fields);
Price new_p = Price(update.price());
Quantity new_q = bts::orderman::get_update_quantity(update);
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);
}
};
LOG(OrderMan, Info, "GLBXNativeOrder::on_update update: {}",
utils::pb::to_string(update));
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);
send_update_in_sim_mode();
}
} 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);
send_update_in_sim_mode();
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);
// TODO: check for sim mode here
if (me->in_sim_mode) {
CancelOrderMsg cxl_msg = {};
cxl_msg.key = key();
LOG(OrderMan, Info, "GLBXNativeOrder queue_order_msg for cxl");
me->services->queue_order_msg(*me->session_services, cxl_msg);
}
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<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;
} else {
// No text based ts we must have a uint64 one
auto ts = std::get<ExchangeTimeStamp64>(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<iLink3OrderEncoder>();
else
me->encoder = std::make_unique<iLink2OrderEncoder>();
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<config::JetFIX>().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<config::OrdermanCfg>()
.fallback_cust_order_handling_inst());
}
// TODO, make it static
NativeOrderType get_glbx_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 GLBXNativeOrder::_create_create_msg(CreateOrderMsg &c) {
c.key = key();
c.price = Price(me->state.price());
c.quantity =
bts::orderman::get_quantity(me->state, StateQuantityType::OrderQuantity);
c.security = me->sec;
c.side = me->definition.side();
c.order_type = get_glbx_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;
LOG(OrderMan, Info, "GLBXNativeOrder::_create_create_msg c.qty: {}",
c.quantity);
}
} // namespace orderman
} // namespace bts