Files
spark/src/server/sparkd/orderman/orders/NativeOrder.cpp
T

1036 lines
36 KiB
C++

#include "NativeOrder.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/logging/logging.h"
#include "lib/utils/PBUtils.h"
#include "server/sparkd/jetfix/codec/FIXFragment.h"
#include "server/sparkd/jetfix/codec/FieldDefinitions.h"
#include "server/sparkd/orderman/order_factory/IOrderFactory.h"
#include "server/sparkd/orderman/order_router/OrderRouter.h"
#include "server/sparkd/orderman/orderman_utils/ExecutionReport.h"
#include "server/sparkd/orderman/orderman_utils/fix_order_codec.h"
#include "server/sparkd/orderman/orders/PreActivationOrderServices.h"
#include "server/sparkd/securities/ISecurityDB.h"
#include "server/sparkd/tracing/bts_trace.h"
#include "server/sparkd/orderman/actors/order_manager/OrderServices.h"
#include <sys/time.h>
namespace bts {
namespace orderman {
using namespace api::orderman;
OrderStatus map_external_status(NativeOrderStatus);
struct NativeOrder::PImpl {
PImpl()
: services(nullptr), session_services(), sec(nullptr),
previous_position_contribution(0), definition(), state(),
price_encoding_precision(7) {}
OrderServices *services;
SessionServices *session_services;
const api::Security *sec;
Quantity previous_position_contribution;
OrderDefinition definition;
OrderState state;
int price_encoding_precision;
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::TransactTimeStr>
update_transact_time_bm;
jetfix::FIXFragment create_encoding;
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::TransactTimeStr>
cancel_transact_time_bm;
};
NativeOrder::NativeOrder() : me(new PImpl()) {}
OrderDefinition const &NativeOrder::definition() const {
return me->definition;
}
void NativeOrder::on_init_new(OrderDefinition const &def,
const PreActivationOrderServices &serv) {
// order was just created.
me->definition = def;
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;
}
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);
} else {
auto rq = serv.order_router.get_routing_record(
UserID(def.user_id()), AccountID(def.account_id()), *me->sec);
if (rq.has_route) {
transition(ORDER_STATUS_INACTIVE);
auto &native_state = get_native_state(me->state);
*native_state.mutable_routing_record() = rq.routing_record;
init_fix();
} else {
auto msg = fmt::format("Could not route order: {}", rq.error_msg);
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
}
}
}
void NativeOrder::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()));
auto const &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;
}
// bail if the session we used for the order is no longer valid
auto const &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)
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 NativeOrder::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_str(er.operator_id), to_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_market();
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);
auto ts = to_trim_str(er.exchange_order_id.value());
native_state.set_exchange_order_id(std::string(ts.first, ts.second));
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();
rr.set_session(er.cfg->name());
rr.set_account(to_str(er.account_name));
rr.set_operator_id(to_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()));
on_init_recovered(orecord, os);
}
NativeOrder::~NativeOrder() {}
void NativeOrder::on_activate(Price p, Quantity q,
bts::orderman::OrderServices &services,
TickToTradeCorID cid) {
tracepoint(bts_trace, trace_order, (char *)"on_activate", 0, cid);
bts_assert(!me->services);
me->services = &services;
switch (me->state.status()) {
case ORDER_STATUS_INACTIVE: {
// this is a brand new order
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->session_services->session_cfg().price_encoding_precision();
// is our gateway connected?
if (!me->session_services->is_gateway_connected()) {
LOG(OrderMan, Warn,
"Attempt to send order to a disconnected gateway. "
"Dropping order {}",
key().value());
transition(ORDER_STATUS_REJECTED_BY_SPARK, "Exchange gateway is down");
break;
}
// 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, Warn,
"Unauthorized order attempted. User: {} on "
"Account: {}. Msg: {} Order: {}. Dropping order",
me->definition.user(), me->definition.account(), lqr.error_msg,
key().value());
transition(ORDER_STATUS_REJECTED_BY_SPARK,
fmt::format("Unauthorized order: {}", lqr.error_msg));
break;
}
// 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, Warn,
"New order would breach limit. User: {} Account: "
"{} Msg: {} Order: {}. Dropping order",
me->definition.user(), me->definition.account(), lqr.error_msg,
key().value());
transition(ORDER_STATUS_REJECTED_BY_SPARK,
fmt::format("Order would breach limit: {}", lqr.error_msg));
break;
}
// are we under the messaging threshold?
if (!me->session_services->governor().can_send()) {
LOG(OrderMan, Warn,
"New order would cause breach of messaging "
"limits. Dropping order {}",
key().value());
transition(ORDER_STATUS_REJECTED_BY_SPARK,
"Messaging threshold breached");
break;
}
// if we are here we are good.
// subscribe to usefull events
me->session_services->exe_reports.sub(
key(), [this](auto const &r) { this->on_exe_report(r); });
me->session_services->cancel_rejects.sub(
key(), [this](auto const &cr) { this->on_cancel_reject(cr); });
me->session_services->gateway_status.sub(
[this](auto const &gw) { this->on_gateway_status(gw); });
// send out order
auto &encoding = me->create_encoding;
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;
}
me->create_quantity_bm =
encoding.overwrite(me->create_quantity_bm, q.value(), quantity_sz());
auto const &ts = services.get_time_str();
me->create_transact_time_bm = encoding.overwrite(
me->create_transact_time_bm, &ts.value()[0], ts.value().size());
auto buffer = me->session_services->get_fix_buffer();
auto &stream = buffer->fix[0];
auto &f = stream.new_msg(jetfix::MessageTypes::NewOrderSingle);
f.append(me->create_encoding);
stream.close();
// Send it
me->session_services->governor().record_sent();
me->session_services->send_fix_buffer(cid, buffer);
me->state.set_status(ORDER_STATUS_PENDING_WORKING);
LOG(OrderMan, Info, "Sent new order with key {} to gateway",
key().value());
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->session_services->exe_reports.sub(
key(), [this](auto const &r) { this->on_exe_report(r); });
me->session_services->cancel_rejects.sub(
key(), [this](auto const &cr) { this->on_cancel_reject(cr); });
me->session_services->gateway_status.sub(
[this](auto const &gw) { this->on_gateway_status(gw); });
if (!me->session_services->is_gateway_connected())
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->session_services->exe_reports.sub(
key(), [this](auto const &r) { this->on_exe_report(r); });
me->session_services->cancel_rejects.sub(
key(), [this](auto const &cr) { this->on_cancel_reject(cr); });
me->session_services->gateway_status.sub(
[this](auto const &gw) { this->on_gateway_status(gw); });
if (me->session_services->is_gateway_connected())
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->session_services->exe_reports.sub(
key(), [this](auto const &r) { this->on_exe_report(r); });
me->session_services->cancel_rejects.sub(
key(), [this](auto const &cr) { this->on_cancel_reject(cr); });
me->session_services->gateway_status.sub(
[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();
}
void NativeOrder::on_update(Price p, Quantity q, TickToTradeCorID cid) {
tracepoint(bts_trace, trace_order, (char *)"on_update", 0, cid);
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);
if (parent_key() == null_order_key())
transition(me->state.status(), msg);
else {
me->state.set_last_msg(msg);
on_cancel(cid);
}
break;
}
// are we under the messaging threshold?
if (!me->session_services->governor().can_send()) {
LOG(OrderMan, Warn,
"Cannot update order {} because of messaging limits. ",
key().value());
auto msg = "Messaging threshold breached";
if (parent_key() == null_order_key())
transition(me->state.status(), msg);
else {
me->state.set_last_msg(msg);
on_cancel(cid);
}
break;
}
// all good
auto &encoding = me->update_encoding;
me->update_price_bm = encoding.overwrite(
me->update_price_bm,
securities::encode_exchange_price(*me->sec, p).value(),
me->price_encoding_precision, price_sz());
me->update_quantity_bm =
encoding.overwrite(me->update_quantity_bm, q.value(), quantity_sz());
auto const &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 buffer = me->session_services->get_fix_buffer();
auto &stream = buffer->fix[0];
auto &f = stream.new_msg(jetfix::MessageTypes::CancelReplace);
f.append(me->update_encoding);
stream.close();
// Send it
me->session_services->governor().record_sent();
me->session_services->send_fix_buffer(cid, buffer);
if (me->state.last_msg().size())
me->state.set_last_msg("");
break;
}
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
transition(me->state.status(), "Cannot update order");
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();
}
void NativeOrder::on_crack(TickToTradeCorID) {}
void NativeOrder::on_cancel(TickToTradeCorID cid) {
switch (me->state.status()) {
case ORDER_STATUS_WORKING: {
auto &encoding = me->cancel_encoding;
auto const &ts = me->services->get_time_str();
me->cancel_transact_time_bm = encoding.overwrite(
me->cancel_transact_time_bm, &ts.value()[0], ts.value().size());
auto buffer = me->session_services->get_fix_buffer();
auto &stream = buffer->fix[0];
auto &f = stream.new_msg(jetfix::MessageTypes::Cancel);
f.append(me->cancel_encoding);
stream.close();
me->session_services->send_fix_buffer(cid, buffer);
break;
}
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
transition(me->state.status(), "Cannot cancel order");
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();
}
void NativeOrder::on_exe_report(const NewExecutionReportEvent &er) {
auto &state = me->state;
auto &native_state = get_native_state(state);
if (native_state.last_msg_seq_num() > er.data->msg_seq_num) {
LOG(OrderMan, Warn,
"Ignoring already seen execution report {} in order {}",
er.data->msg_seq_num, key().value());
return;
}
native_state.set_last_msg_seq_num(er.data->msg_seq_num);
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);
if (native_state.exchange_order_id().empty()) {
auto ts = to_trim_str(er.data->exchange_order_id.value());
native_state.set_exchange_order_id(std::string(ts.first, ts.second));
add_exchange_order_id_to_fix();
}
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:
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->session_services->is_gateway_connected())
transition(ORDER_STATUS_DISCONNECTED);
else
transition(external_status);
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();
}
void NativeOrder::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 NativeOrder::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()));
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 NativeOrder::report_state() {
if (me->sec) {
auto current_position = position_contribution();
auto previous_position = me->previous_position_contribution;
me->previous_position_contribution = current_position;
if (current_position.value() > previous_position.value())
me->services->limiter().add(
*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(
*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());
me->services->report_state(me->state);
}
void NativeOrder::init_fix() {
bts_assert(me->sec);
using namespace jetfix;
auto const &def = me->definition;
auto const &sec = *me->sec;
auto const &rr = get_native_state(me->state).routing_record();
std::string clordid(clordid_sz(), ' ');
encode_clorid(key(), SecurityKey(sec.id()), &clordid);
// initialize create FIX
auto &create_encoding = me->create_encoding;
create_encoding.add<fix::SenderSubID>(rr.operator_id());
create_encoding.add<fix::Account>(rr.account());
create_encoding.add<fix::Side>(def.side());
create_encoding.add<fix::TimeInForce>(def.time_in_force());
create_encoding.add<fix::ManualOrderIndicator>(def.manual_order_indicator());
create_encoding.add<fix::CustomerOrFirm>(rr.customer_or_firm());
create_encoding.add<fix::CtiCode>(rr.cti_code());
create_encoding.add<fix::SecurityDesc>(sec.glbx().security_desc());
create_encoding.add<fix::ClOrdID>(clordid);
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());
// initialize update FIX
auto &update_encoding = me->update_encoding;
update_encoding.add<fix::SenderSubID>(rr.operator_id());
update_encoding.add<fix::Account>(rr.account());
update_encoding.add<fix::Side>(def.side());
update_encoding.add<fix::TimeInForce>(def.time_in_force());
update_encoding.add<fix::ManualOrderIndicator>(def.manual_order_indicator());
update_encoding.add<fix::CtiCode>(rr.cti_code());
update_encoding.add<fix::CustomerOrFirm>(rr.customer_or_firm());
update_encoding.add<fix::SecurityDesc>(sec.glbx().security_desc());
update_encoding.add<fix::ClOrdID>(clordid);
update_encoding.add<fix::OrigClOrdID>(clordid);
update_encoding.add<fix::CorrelationClOrdID>(clordid);
update_encoding.add<fix::InFlightMitigation>(true);
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());
// initialize cancel FIX
auto &cancel_encoding = me->cancel_encoding;
cancel_encoding.add<fix::SenderSubID>(rr.operator_id());
cancel_encoding.add<fix::Account>(rr.account());
cancel_encoding.add<fix::Side>(def.side());
cancel_encoding.add<fix::TimeInForce>(def.time_in_force());
cancel_encoding.add<fix::ManualOrderIndicator>(def.manual_order_indicator());
cancel_encoding.add<fix::SecurityDesc>(sec.glbx().security_desc());
cancel_encoding.add<fix::ClOrdID>(clordid);
cancel_encoding.add<fix::OrigClOrdID>(clordid);
cancel_encoding.add<fix::CorrelationClOrdID>(clordid);
me->cancel_transact_time_bm = cancel_encoding.add<fix::TransactTimeStr>(
datetime::FIX_timestamp(datetime::now()));
// 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);
update_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);
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 NativeOrder::add_exchange_order_id_to_fix() {
bts_assert(has_exchange_order_id());
auto &state = get_native_state(me->state);
auto &eoid = state.exchange_order_id();
me->update_encoding.add<jetfix::fix::OrderID>(eoid);
me->cancel_encoding.add<jetfix::fix::OrderID>(eoid);
}
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 NativeOrder::has_exchange_order_id() {
return get_native_state(me->state).exchange_order_id().size();
}
void NativeOrder::transition(api::orderman::OrderStatus new_status,
std::string const &msg) {
auto const &from = OrderStatus_Name(me->state.status());
auto const &to = OrderStatus_Name(new_status);
LOG(OrderMan, Info, "Transitioning order {} from {} to {}. Msg: {}",
key().value(), from, to, msg);
me->state.set_status(new_status);
me->state.set_last_msg(msg);
}
void NativeOrder::transition(api::orderman::OrderStatus new_status) {
auto const &from = OrderStatus_Name(me->state.status());
auto const &to = OrderStatus_Name(new_status);
LOG(OrderMan, Info, "Transitioning order {} from {} to {}", key().value(),
from, to);
me->state.set_status(new_status);
}
void NativeOrder::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 NativeOrder::position_contribution() {
switch (me->state.status()) {
case ORDER_STATUS_WORKING:
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_DISCONNECTED:
return Quantity(
std::max(me->state.quantity(), me->state.filled_quantity()));
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
return Quantity(me->state.filled_quantity());
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 NativeOrder::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 &
NativeOrder::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();
}
} // namespace orderman
} // namespace bts