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

1378 lines
50 KiB
C++

#include "ICENativeOrder.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/Security.h"
#include "lib/jetfix/codec/FIXFragment.h"
#include "lib/jetfix/codec/FieldDefinitions.h"
#include "lib/logging/logging.h"
#include "lib/orderman/order_factory/IOrderFactory.h"
#include "lib/orderman/order_router/OrderRouter.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/securities/ISecurityDB.h"
#include "lib/md/IntPrice.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/Puid.h"
#include "lib/utils/bts_chrono.h"
#include "lib/orderman/actors/order_manager/OrderServices.h"
#include <algorithm>
#include <math.h>
#include <sys/time.h>
#include <queue>
namespace bts {
namespace orderman {
using namespace api::orderman;
OrderStatus map_external_status(NativeOrderStatus); //in GLBXNativeOrder.cpp
struct ICENativeOrder::PImpl
{
PImpl()
: services(nullptr), session_services(), sec(nullptr),
previous_working_position(0), definition(), state(),
price_encoding_precision(7), exchange_order_id(), sender_compid(), id_scale()
{
exchange_order_id.reserve(100);
}
OrderServices *services;
SessionServices *session_services;
const api::Security *sec;
Quantity previous_working_position;
OrderDefinition definition;
OrderState state;
int price_encoding_precision;
std::string exchange_order_id;
int sender_compid;
int64_t id_scale;
jetfix::FIXFragment update_encoding;
jetfix::FIXFragment::Bookmark<jetfix::fix::Price> update_price_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::OrderQty> update_quantity_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::StopPx> update_stop_px_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::TransactTimeStr> update_transact_time_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_ClOrdID> update_clordid_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_OrigClOrdID> update_orig_clordid_bm;
jetfix::FIXFragment create_encoding;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_ClOrdID> create_clordid_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::Price> create_price_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::OrderQty> create_quantity_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::TransactTimeStr> create_transact_time_bm;
jetfix::FIXFragment cancel_encoding;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_ClOrdID> cancel_clordid_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_OrigClOrdID> cancel_orig_clordid_bm;
OrderServices::ExeReportSubID exe_report_sid;
OrderServices::CancelRejectSubID cancel_reject_sid;
bool buffered_cancel = false;
std::optional<std::pair<Price, Quantity>> buffered_update;
int buffered_tries = 0;
};
// on outgoing order, converts the qty to exchange terms
// (ex HNG that is represented as 1 in the system and
// multiples of 2500 at ICE)
Quantity to_exchange_qty (const api::Security& sec, Quantity internal_qty){
return bts::securities::to_exchange_qty(internal_qty,sec);
}
ICENativeOrder::ICENativeOrder() : me(new PImpl()) {}
const OrderDefinition& ICENativeOrder::definition() const
{
return me->definition;
}
void ICENativeOrder::on_init_new(const OrderDefinition& 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;
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);
me->state.set_last_msg(msg);
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
return;
}
transition(ORDER_STATUS_INACTIVE);
auto &native_state = get_native_state(me->state);
*native_state.mutable_routing_record() = rq.routing_record;
setup_ids(rq.routing_record.sender_compid());
init_fix();
}
void ICENativeOrder::init_recovered_common(const api::orderman::OrderRecord& rec, const PreActivationOrderServices& serv)
{
// order was recovered from our orders database or from an execution report
const auto &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);
const auto &native_state = get_native_state(me->state);
setup_ids(native_state.routing_record().sender_compid());
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;
}
// bail if the session we used for the order is no longer valid
const auto &session = native_state.routing_record().session();
if (!serv.order_router.is_valid_session(session))
{
LOG(OrderMan, Error,
"Unknown JetFIX session {} referenced by recovered order {}. This is a serious "
"problem which has to be corrected manually. ",
session, rec.key());
transition_to_error(NativeOrderState::SUB_ERROR_UNKNOWN_FIX_SESSION,
fmt::format("Unknown FIX session: {}", session));
return;
}
// if we made it this far we are good.
init_fix();
if (me->state.status() != ORDER_STATUS_PENDING_WORKING)
{
me->exchange_order_id = native_state.exchange_order_id();
add_exchange_order_id_to_fix();
}
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;
}
}
void ICENativeOrder::on_init_recovered(const OrderRecord& rec, const PreActivationOrderServices& serv)
{
//TODO need to figure out if this is a day order from a prev session and cancel it
// const auto &def = rec.def();
// auto &state = *orecord.mutable_state();
// state.set_status(map_external_status(api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_CANCELED);
init_recovered_common(rec, serv);
}
api::orderman::OrderDefinition
ICENativeOrder::on_init_from_exe_report(const ExecutionReport& 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(), std::to_string(er.ice_company_id),
to_trim_str(er.account_name), sec);
if (rev_rec.ok)
{
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 account and user information from order {}. The following information is available: {}. ",
k.value(), 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:
def.mutable_custom_def()->mutable_limit();
state.mutable_limit();
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);
native_state.set_exchange_order_id(to_trim_str(er.exchange_order_id));
native_state.set_last_msg_seq_num(er.msg_seq_num);
native_state.set_native_type(er.order_type);
auto &rr = *native_state.mutable_routing_record();
bool real_routing = false;
if (rev_rec.ok && sec)
{
const auto& real_rr = os.order_router.get_routing_record(rev_rec.user_id, rev_rec.account_id, *sec);
if(real_rr.has_route)
{
rr.CopyFrom(real_rr.routing_record);
real_routing = true;
}
}
if(!real_routing)
{
rr.set_sender_compid(er.cfg->sender_compid());
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());
}
init_recovered_common(orecord, os);
return orecord.def();
}
ICENativeOrder::~ICENativeOrder() {}
void ICENativeOrder::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
ICENativeOrder::_on_activate(log::Level reject_level, log::Level transition_level,
Price p, Quantity activate_q, bts::orderman::OrderServices &services)
{
me->state.set_price(p.value());
me->state.set_quantity(activate_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(), activate_q, p);
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](const auto &r) { this->on_exe_report(r); });
me->cancel_reject_sid = me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](const auto &gw) { this->on_gateway_status(gw); });
// send out order
auto &encoding = me->create_encoding;
auto create_clorid = get_new_clordid();
me->create_clordid_bm = encoding.overwrite( me->create_clordid_bm, create_clorid, count_digits(create_clorid) );
switch (me->definition.custom_def().custom_case())
{
case CustomOrderDefinition::kLimit:
case CustomOrderDefinition::kStopLimit:
{
me->create_price_bm = encoding.overwrite(me->create_price_bm,
securities::encode_exchange_price(*me->sec, p).value(),
me->price_encoding_precision, price_sz());
break;
}
case CustomOrderDefinition::kStop:
case CustomOrderDefinition::kMarket:
break;
default:
bts_assert(false);
break;
}
auto exchange_qty = to_exchange_qty(*me->sec,activate_q);
me->create_quantity_bm = encoding.overwrite(me->create_quantity_bm, exchange_qty.value(), quantity_sz());
const auto &ts = services.get_time_str();
me->create_transact_time_bm = encoding.overwrite(me->create_transact_time_bm, &ts.value()[0], ts.value().size());
return OrderOpResult{};
}
OrderOpResult ICENativeOrder::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:
{
auto scoped_log = services.log_scope("ICENativeOrder::on_activate", key().value());
// this is a brand new order
result = _on_activate(Warn, Info, p, q, services);
if (result.ok())
{
me->services->queue_fix(*me->session_services, jetfix::MessageTypes::NewOrderSingle, me->create_encoding);
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](const auto &r) { this->on_exe_report(r); });
me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](const auto &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](const auto &r) { this->on_exe_report(r); });
me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](const auto &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](const auto &r) { this->on_exe_report(r); });
me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](const auto &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 ICENativeOrder::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 ICENativeOrder::on_update(api::orderman::Update const &update)
{
auto p = Price(update.price());
auto update_q = Quantity(update.quantity());
auto scoped_log = me->services->log_scope("ICENativeOrder::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 (update_q.value() > me->state.filled_quantity())
current_working_qty = update_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),Price(p));
// 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;
}
auto &encoding = me->update_encoding;
if (update.has_custom())
{
bts_assert(update.custom().custom_case() == me->definition.custom_def().custom_case());
if (update.custom().custom_case() == CustomOrderDefinition::kStopLimit)
{
auto const &stop_limit = update.custom().stop_limit();
auto stop_px = Price(stop_limit.stop_price());
me->update_stop_px_bm = encoding.overwrite(me->update_stop_px_bm,
securities::encode_exchange_price(*me->sec, stop_px).value(),
me->price_encoding_precision, price_sz());
}
}
me->update_price_bm = encoding.overwrite(me->update_price_bm, securities::encode_exchange_price(*me->sec, p).value(),
me->price_encoding_precision, price_sz());
auto exchange_qty = to_exchange_qty(*me->sec,update_q);
me->update_quantity_bm = encoding.overwrite(me->update_quantity_bm, exchange_qty.value(), quantity_sz());
const auto &ts = me->services->get_time_str();
me->update_transact_time_bm = encoding.overwrite( me->update_transact_time_bm, &ts.value()[0], ts.value().size() );
auto update_clorid = get_new_clordid();
me->update_clordid_bm = encoding.overwrite( me->update_clordid_bm, update_clorid, count_digits(update_clorid) );
me->services->queue_fix(*me->session_services, jetfix::MessageTypes::CancelReplace, me->update_encoding);
me->services->governor(*me->session_services).record_sent();
update_working_position();
if (me->state.last_msg().size())
me->state.set_last_msg("");
LOG(OrderMan, Info,
"ICE may not honor this update if we recently issued an unacknowledged cancelreplace {}. Update: {}@{}. Buffering",
key().value(), update_q.value(), p.value());
me->buffered_update.emplace(p, update_q);
// 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_q.value(), p.value());
me->buffered_update.emplace(p, update_q);
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 ICENativeOrder::on_detach() { return OrderOpResult{}; }
void ICENativeOrder::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;
// setup_ids(rq.routing_record.sender_compid());
// init_fix();
// if (has_exchange_order_id())
// add_exchange_order_id_to_fix();
//ICE is a little different with some of these tags, there is no manual order reported and the user is really
//not the user we are updating here. So we can update the BTS data but not reinit the fix
//We should not reinit the fix because we need to correctly cache the orig_clordid for cancels and updates subsequent to
//the first update.
// 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 ICENativeOrder::on_cancel()
{
auto scoped_log = me->services->log_scope("ICENativeOrder::on_cancel", key().value());
auto result = OrderOpResult{};
switch (me->state.status())
{
case ORDER_STATUS_WORKING:
{
auto &encoding = me->cancel_encoding;
auto cancel_clorid = get_new_clordid();
me->cancel_clordid_bm = encoding.overwrite( me->cancel_clordid_bm, cancel_clorid, count_digits(cancel_clorid) );
me->services->queue_fix(*me->session_services, jetfix::MessageTypes::Cancel,me->cancel_encoding);
me->buffered_cancel = true;
LOG(OrderMan, Warn,
"ICE May not honor this cancel if we'd previously issued an unacknowledged cancelreplace "
"Buffering cancel to be safe",
key().value());
break;
}
case ORDER_STATUS_CANCELED:
break;
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_ERROR:
result.error = ORDER_ERROR_INVALID_OP;
result.error_msg = "Order is already terminated";
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 ICENativeOrder::is_old_exe_report(api::orderman::NativeOrderState &native_state, const NewExecutionReportEvent &er) const
{
if (native_state.last_transact_time().size() != sizeof(mercury::TimeStampStr))
return false;
if (std::lexicographical_compare(native_state.last_transact_time().begin(),
native_state.last_transact_time().end(),
er.data->transact_time.value().begin(),
er.data->transact_time.value().end()))
return false;
if (std::equal(native_state.last_transact_time().begin(),
native_state.last_transact_time().end(),
er.data->transact_time.value().begin(),
er.data->transact_time.value().end()))
return native_state.last_msg_seq_num() >= er.data->msg_seq_num;
return true;
}
void ICENativeOrder::on_exe_report(const NewExecutionReportEvent &er)
{
auto scoped_log = me->services->log_scope("ICENativeOrder::on_exe_report", key().value());
auto &state = me->state;
auto &native_state = get_native_state(state);
if(er.data->exec_type == api::orderman::ExecType::EXEC_TYPE_TRADE_CANCEL ||
er.data->exec_type == api::orderman::ExecType::EXEC_TYPE_TRADE_CORRECT)
{
LOG(OrderMan, Error, "ICENativeOrder ignoring Cancel or Correct execution report {} in order {}", er.data->msg_seq_num, key().value());
return;
}
// 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);
native_state.set_last_transact_time(to_str(er.data->transact_time));
auto external_status = map_external_status(er.data->order_status);
if (external_status != ORDER_STATUS_CANCELED)
{
state.set_avg_price(er.data->avg_price.value());
state.set_filled_quantity(er.data->filled_quantity.value());
state.set_last_price(er.data->last_price.value());
//cache the new clordid
if(er.data->ice_cl_ord_id > 0)
{
auto clordid = er.data->ice_cl_ord_id;
me->update_orig_clordid_bm = me->update_encoding.overwrite( me->update_orig_clordid_bm, clordid, count_digits(clordid) );
me->cancel_orig_clordid_bm = me->cancel_encoding.overwrite( me->cancel_orig_clordid_bm, clordid, count_digits(clordid) );
}
}
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);
bool got_first_exchange_order_id = !has_exchange_order_id();
if (got_first_exchange_order_id)
{
me->exchange_order_id = to_trim_str(er.data->exchange_order_id);
native_state.set_exchange_order_id(me->exchange_order_id);
add_exchange_order_id_to_fix();
}
if (!terminal_state(me->state.status()))
{
if(!isnan(er.data->price.value()))
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:
me->buffered_cancel = false;
me->buffered_update.reset();
break;
// 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)
{
handle_buffered_state("first ack");
}
}
break;
case ORDER_STATUS_WORKING:
{
transition(external_status);
if(me->buffered_update)
{
auto [p, q] = me->buffered_update.value();
if(er.data->price.value() == p.value() && er.data->quantity.value() == q.value())
me->buffered_update.reset();
if(me->buffered_tries++ > 10)
{
me->buffered_tries = 0;
me->buffered_update.reset();
}
}
handle_buffered_state("working");
}
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 ICENativeOrder::handle_buffered_state(const std::string& condition)
{
if (me->buffered_cancel)
{
LOG(OrderMan, Info,
"Applying buffered cancel to order {}, on ",
condition,
key().value());
on_cancel();
}
else if (me->buffered_update.has_value())
{
auto [p, q] = me->buffered_update.value();
LOG(OrderMan, Info,
"Applying buffered update ({}@{}) to order {}, on ",
condition,
q.value(),p.value(), key().value());
on_update(p, q);
}
}
void ICENativeOrder::on_cancel_reject(const orderman::CancelRejectEvent &cr)
{
auto &state = me->state;
state.set_last_msg(cr.reject_msg);
LOG(OrderMan, Warn, "Cancel reject received for order {}", key().value());
switch (me->state.status())
{
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_WORKING:
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();
}
void ICENativeOrder::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:
break;
case ORDER_STATUS_WORKING:
break;
case ORDER_STATUS_DISCONNECTED:
{
const auto &native_state = get_native_state(me->state);
transition(map_external_status(native_state.native_status()));
if (me->state.status() == ORDER_STATUS_WORKING)
{
handle_buffered_state("re-connection");
}
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 ICENativeOrder::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 ICENativeOrder::report_state()
{
update_working_position();
me->services->report_state(me->state);
}
void ICENativeOrder::setup_ids(const std::string& sender_compid)
{
me->sender_compid = std::atoi(sender_compid.c_str());
int digs = count_digits(me->sender_compid);
me->id_scale = md::pow10(ice_orderid_sz()-digs);
}
int64_t ICENativeOrder::get_clordid(uint64_t bts_id)
{
int64_t id = me->id_scale * std::max(me->sender_compid, 1) + (bts_id % me->id_scale);
return id;
}
int64_t ICENativeOrder::get_new_clordid()
{
return get_clordid(me->services->gen_id());
}
void ICENativeOrder::init_fix()
{
bts_assert(me->sec);
using namespace jetfix;
me->create_encoding = FIXFragment{};
me->update_encoding = FIXFragment{};
me->cancel_encoding = FIXFragment{};
const auto &def = me->definition;
const auto &sec = *me->sec;
bts_assert(sec.has_ice());
const auto &rr = get_native_state(me->state).routing_record();
std::string memo(memo_sz(), ' ');
encode_memo(key(), SecurityKey(sec.id()), &memo);
// initialize create FIX
auto &create_encoding = me->create_encoding;
create_encoding.add<fix::Memo>(memo);
me->create_clordid_bm = create_encoding.add<fix::Int_ClOrdID>(get_clordid(0), ice_orderid_sz());
create_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));
std::string on_behalf = rr.sender_compid() + "|" + rr.sender_compid();
create_encoding.add<fix::OnBehalfOfCompID>(on_behalf);
std::string cust = rr.cust_order_handing_inst();
if(cust == "")
cust = "Y";
create_encoding.add<fix::CustOrderHandlingInst>(cust);
create_encoding.add<fix::SenderSubID>(rr.operator_id());
create_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.authorized_trader());
create_encoding.add<fix::OnBehalfOfLocationID>("DAU|" + rr.authorized_group());
create_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
create_encoding.add<fix::HandlInst>('1');
create_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
create_encoding.add<fix::Side>(def.side());
me->create_transact_time_bm = create_encoding.add<fix::TransactTimeStr>(datetime::FIX_timestamp(datetime::now()));
me->create_quantity_bm = create_encoding.add<fix::OrderQty>(0, quantity_sz());
create_encoding.add<fix::TimeInForce>(def.time_in_force());
if(rr.account() != "")
create_encoding.add<fix::ClearingAccount>(rr.account());
if(rr.clearing_firm() != "")
create_encoding.add<fix::Int_ClearingFirm>(std::atoi(rr.clearing_firm().c_str()));
if(rr.account_code() != "")
create_encoding.add<fix::AccountCode>(rr.account_code()[0]);
if(rr.cti_code() != api::orderman::CTICode::CTI_CODE_UNDEFINED)
create_encoding.add<fix::Int_CtiCode>( rr.cti_code() - '0' );
if(rr.customer_account_ref_id() != "")
create_encoding.add<fix::CustomerAccountRefId>(rr.customer_account_ref_id());
// initialize update FIX
auto &update_encoding = me->update_encoding;
update_encoding.add<fix::Memo>(memo);
me->update_orig_clordid_bm = update_encoding.add<fix::Int_OrigClOrdID>(get_clordid(0), ice_orderid_sz());
update_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));
update_encoding.add<fix::OnBehalfOfCompID>(on_behalf);
update_encoding.add<fix::SenderSubID>(rr.operator_id());
update_encoding.add<fix::OnBehalfOfSubID>(rr.operator_id() + "|" + rr.authorized_trader());
update_encoding.add<fix::OnBehalfOfLocationID>("DAU|" + rr.authorized_group());
update_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
update_encoding.add<fix::HandlInst>('1');
update_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
update_encoding.add<fix::Side>(def.side());
me->update_transact_time_bm = update_encoding.add<fix::TransactTimeStr>(datetime::FIX_timestamp(datetime::now()));
me->update_quantity_bm = update_encoding.add<fix::OrderQty>(0, quantity_sz());
me->update_clordid_bm = update_encoding.add<fix::Int_ClOrdID>(get_clordid(0), ice_orderid_sz());
update_encoding.add<fix::TimeInForce>(def.time_in_force());
if(rr.account() != "")
update_encoding.add<fix::ClearingAccount>(rr.account());
if(rr.clearing_firm() != "")
update_encoding.add<fix::Int_ClearingFirm>(std::atoi(rr.clearing_firm().c_str()));
if(rr.account_code() != "")
update_encoding.add<fix::AccountCode>(rr.account_code()[0]);
if(rr.cti_code() != api::orderman::CTICode::CTI_CODE_UNDEFINED)
update_encoding.add<fix::Int_CtiCode>( rr.cti_code() - '0' );
if(rr.customer_account_ref_id() != "")
update_encoding.add<fix::CustomerAccountRefId>(rr.customer_account_ref_id());
// initialize cancel FIX
auto &cancel_encoding = me->cancel_encoding;
cancel_encoding.add<fix::Memo>(memo);
me->cancel_orig_clordid_bm = cancel_encoding.add<fix::Int_OrigClOrdID>(get_clordid(0), ice_orderid_sz());
cancel_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));
cancel_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
cancel_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
cancel_encoding.add<fix::Side>(def.side());
me->cancel_clordid_bm = cancel_encoding.add<fix::Int_ClOrdID>(get_clordid(0), ice_orderid_sz());
// special tags
switch (def.custom_def().custom_case())
{
case CustomOrderDefinition::kMarket:
// type
create_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_MARKET);
update_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_MARKET);
cancel_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_MARKET);
break;
case CustomOrderDefinition::kLimit:
// type
create_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_LIMIT);
update_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_LIMIT);
cancel_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_LIMIT);
// price
me->create_price_bm = create_encoding.add<fix::Price>(0, me->price_encoding_precision, price_sz());
me->update_price_bm = update_encoding.add<fix::Price>(0, me->price_encoding_precision, price_sz());
break;
case CustomOrderDefinition::kStop:
{
// type
create_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_STOP);
update_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_STOP);
cancel_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_STOP);
// stop px
auto stop_px = def.custom_def().stop().stop_price();
auto encoded_stop_px = securities::encode_exchange_price(*me->sec, Price(stop_px)).value();
create_encoding.add<fix::StopPx>(encoded_stop_px, me->price_encoding_precision, -1);
break;
}
case CustomOrderDefinition::kStopLimit:
{
// type
create_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_STOP_LIMIT);
update_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_STOP_LIMIT);
cancel_encoding.add<fix::OrdType>(NATIVE_ORDER_TYPE_STOP_LIMIT);
// stop px
auto stop_px = def.custom_def().stop_limit().stop_price();
auto encoded_stop_px = securities::encode_exchange_price(*me->sec, Price(stop_px)).value();
create_encoding.add<fix::StopPx>(encoded_stop_px, me->price_encoding_precision, -1);
me->update_stop_px_bm = update_encoding.add<fix::StopPx>(encoded_stop_px, me->price_encoding_precision, -1);
// price
me->create_price_bm = create_encoding.add<fix::Price>(0, me->price_encoding_precision, price_sz());
me->update_price_bm = update_encoding.add<fix::Price>(0, me->price_encoding_precision, price_sz());
break;
}
default:
bts_assert(false);
break;
}
}
void ICENativeOrder::add_exchange_order_id_to_fix()
{
bts_assert(has_exchange_order_id());
me->update_encoding.add<jetfix::fix::OrderID>(me->exchange_order_id);
me->cancel_encoding.add<jetfix::fix::OrderID>(me->exchange_order_id);
}
bool ICENativeOrder::has_exchange_order_id()
{
return me->exchange_order_id.size();
}
void ICENativeOrder::transition(api::orderman::OrderStatus new_status, std::string const &msg)
{
transition(Info, new_status, msg);
}
void ICENativeOrder::transition(log::Level level, api::orderman::OrderStatus new_status, std::string const &msg)
{
const auto &from = OrderStatus_Name(me->state.status());
const auto &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 ICENativeOrder::transition(api::orderman::OrderStatus new_status)
{
const auto &from = OrderStatus_Name(me->state.status());
const auto &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 ICENativeOrder::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 ICENativeOrder::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 ICENativeOrder::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& ICENativeOrder::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();
default:
break;
}
// just to appease compiler
bts_assert(false);
return *st.mutable_stop_limit()->mutable_native_state();
}
void ICENativeOrder::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};
}
} // namespace orderman
} // namespace bts