1027 lines
35 KiB
C++
1027 lines
35 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,0);
|
|
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,0);
|
|
|
|
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, -1, -1);
|
|
update_encoding.add<fix::StopPx>(encoded_stop_px, -1, -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, -1, -1);
|
|
update_encoding.add<fix::StopPx>(encoded_stop_px, -1, -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();
|
|
}
|
|
}
|
|
}
|