733 lines
27 KiB
C++
733 lines
27 KiB
C++
#include "EMNativeOrder.h"
|
|
#include "lib/api/services/OrderService.pb.h"
|
|
#include "lib/config/config.h"
|
|
#include "lib/config/protos/orderman_cfg.pb.h"
|
|
#include "lib/config/protos/toggles.pb.h"
|
|
#include "lib/domain/OrderStatus.h"
|
|
#include "lib/domain_model/Security.h"
|
|
#include "lib/domain_model/common.h"
|
|
#include "lib/jetfix/codec/FIXFragment.h"
|
|
#include "lib/jetfix/codec/FieldDefinitions.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/orderman/CancelOrderMsg.h"
|
|
#include "lib/orderman/CancelReplaceOrderMsg.h"
|
|
#include "lib/orderman/CreateOrderMsg.h"
|
|
#include "lib/orderman/OrderRouter.h"
|
|
#include "lib/orderman/OrderServices.h"
|
|
#include "lib/orderman/order_factory/IOrderFactory.h"
|
|
#include "lib/orderman/orderman_utils/ExecutionReport.h"
|
|
#include "lib/orderman/orderman_utils/fix_order_codec.h"
|
|
#include "lib/orderman/orderman_utils/orderman_common.h"
|
|
#include "lib/orderman/orders/OrderOpResult.h"
|
|
#include "lib/orderman/orders/PreActivationOrderServices.h"
|
|
#include "lib/orderman/orders/algo/IAlgoOrder.h"
|
|
#include "lib/orderman/orders/glbx/IGLBXOrderEncoder.h"
|
|
#include "lib/orderman/orders/glbx/iLink2OrderEncoder.h"
|
|
#include "lib/orderman/orders/glbx/iLink3OrderEncoder.h"
|
|
#include "lib/orderman/securities/ISecurityDB.h"
|
|
#include "lib/os/os.h"
|
|
#include "lib/utils/PBUtils.h"
|
|
#include "lib/utils/bts_assert.h"
|
|
#include "lib/utils/bts_chrono.h"
|
|
#include "server/sparkd/md/platforms/emumba/EmMDListener.h"
|
|
#include <algorithm>
|
|
#include <bits/stdint-uintn.h>
|
|
#include <string>
|
|
#include <sys/time.h>
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
using namespace api::orderman;
|
|
|
|
struct EMNativeOrder::PImpl {
|
|
PImpl()
|
|
: services(nullptr), session_services(), sec(nullptr),
|
|
previous_working_position(0), definition(), state(),
|
|
exchange_order_id() {}
|
|
bool inited = false;
|
|
OrderServices *services;
|
|
SessionServices *session_services;
|
|
const api::Security *sec;
|
|
|
|
Quantity previous_working_position;
|
|
|
|
OrderDefinition definition;
|
|
OrderState state;
|
|
std::optional<ExchangeOrderIDVar> exchange_order_id;
|
|
|
|
OrderServices::ExeReportSubID exe_report_sid;
|
|
OrderServices::CancelRejectSubID cancel_reject_sid;
|
|
|
|
bool buffered_cancel = false;
|
|
std::optional<api::orderman::Update> buffered_update;
|
|
RoutingRecord routing_record;
|
|
};
|
|
|
|
EMNativeOrder::EMNativeOrder() : me(new PImpl()) {
|
|
LOG(OrderMan, Info, "EMNativeOrder::EMNativeOrder t_id: {} t_name: {}",
|
|
os::get_thread_id(), os::get_application_name());
|
|
}
|
|
|
|
EMNativeOrder::~EMNativeOrder() {}
|
|
|
|
api::orderman::OrderDefinition const &EMNativeOrder::definition() const {
|
|
return me->definition;
|
|
}
|
|
|
|
// Construction, the order is not yet live and it may never
|
|
// be. This can be slow. This is the first call
|
|
void EMNativeOrder::on_init_new(
|
|
api::orderman::OrderDefinition const &def,
|
|
const PreActivationOrderServices &serv) {
|
|
bts_assert(!me->inited);
|
|
me->inited = true;
|
|
LOG(OrderMan, Info,
|
|
"EMNativeOrder::on_init_new key: {} sec_key: {} user: {} account: {}",
|
|
key(), def.security_key(), def.user(), def.account());
|
|
me->definition = def;
|
|
me->sec = serv.sec_db.resolve(SecurityKey(def.security_key()));
|
|
// Check for invariants, if not met, reject the order
|
|
// 1. Sec can be resolved
|
|
// 2. Order is either Limit or Market
|
|
// 3. Routing Record can be constructed (serv.order_router.get_routing_record
|
|
// returns a valid record)
|
|
// Else, transition to ORDER_STATUS_INACTIVE, and set native state
|
|
if (!me->sec) {
|
|
auto msg = fmt::format("Unknown security: {}", def.security_key());
|
|
me->state.set_last_msg(msg);
|
|
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return;
|
|
}
|
|
switch (def.custom_def().custom_case()) {
|
|
case CustomOrderDefinition::kMarket:
|
|
me->state.mutable_market();
|
|
break;
|
|
case CustomOrderDefinition::kLimit:
|
|
me->state.mutable_limit();
|
|
break;
|
|
default: {
|
|
auto msg = "Order type not supported at this venue";
|
|
me->state.set_last_msg(msg);
|
|
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return;
|
|
}
|
|
}
|
|
switch (def.time_in_force()) {
|
|
case TIME_IN_FORCE_DAY:
|
|
case TIME_IN_FORCE_IOC:
|
|
case TIME_IN_FORCE_GTC:
|
|
break;
|
|
default: {
|
|
auto msg = "Time In Force not supported at this venue";
|
|
me->state.set_last_msg(msg);
|
|
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return;
|
|
}
|
|
}
|
|
auto rq = serv.order_router.get_routing_record(
|
|
UserID(def.user_id()), AccountID(def.account_id()), *me->sec);
|
|
|
|
if (!rq.has_route) {
|
|
auto msg = fmt::format("Could not route order: {}", rq.error_msg);
|
|
LOG(OrderMan, Error, "{}", msg);
|
|
transition(ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return;
|
|
}
|
|
// Successful order always starts in ORDER_STATUS_INACTIVE
|
|
transition(ORDER_STATUS_INACTIVE);
|
|
auto &native_state = get_native_state(me->state);
|
|
me->routing_record = rq.routing_record;
|
|
*native_state.mutable_routing_record() = rq.routing_record;
|
|
LOG(OrderMan, Info, "EMNativeOrder::on_init_new key: {} routing_record: {}",
|
|
key(), utils::pb::to_string(me->routing_record));
|
|
}
|
|
|
|
// We dont recover order. So if it is non terminal, we mark it as error
|
|
void EMNativeOrder::on_init_recovered(
|
|
api::orderman::OrderRecord const &rec,
|
|
const PreActivationOrderServices &serv) {
|
|
bts_assert(!me->inited);
|
|
me->inited = true;
|
|
me->definition = rec.def();
|
|
me->state = rec.state();
|
|
me->sec = serv.sec_db.resolve(SecurityKey(me->definition.security_key()));
|
|
me->previous_working_position = Quantity(0);
|
|
LOG(OrderMan, Info,
|
|
"EMNativeOrder::on_init_recovered key: {} sec_id: {} status: {} "
|
|
"t_id: "
|
|
"{} t_name: {}",
|
|
key(), me->sec == nullptr ? 0 : me->sec->id(),
|
|
OrderStatus_Name(me->state.status()), os::get_thread_id(),
|
|
os::get_application_name());
|
|
if (in_terminal_state(rec.state().status())) {
|
|
transition(rec.state().status());
|
|
} else
|
|
transition(
|
|
OrderStatus::ORDER_STATUS_ERROR, "Recovered Orders are not handled");
|
|
}
|
|
|
|
OrderOpResult EMNativeOrder::on_activate(
|
|
Price p, Quantity q, OrderServices &services) {
|
|
bts_assert(me->inited);
|
|
LOG(OrderMan, Info, "EMNativeOrder::on_activate key: {} p: {} q: {}", key(),
|
|
p, q);
|
|
bts_assert(!me->services);
|
|
me->services = &services;
|
|
auto result = OrderOpResult{};
|
|
switch (me->state.status()) {
|
|
|
|
case ORDER_STATUS_INACTIVE: {
|
|
// this is a brand new order
|
|
// _on_activate sets the price, quantity
|
|
result = _on_activate(Warn, Info, p, q, services);
|
|
if (result.ok()) {
|
|
CreateOrderMsg c_msg = {};
|
|
_create_create_msg(c_msg);
|
|
transition(ORDER_STATUS_PENDING_WORKING);
|
|
me->services->queue_order_msg(*me->session_services, c_msg);
|
|
me->services->governor(*me->session_services).record_sent();
|
|
LOG(OrderMan, Info,
|
|
"EMNativeOrder::on_activate sent new order with key {} to "
|
|
"gateway",
|
|
key().value());
|
|
// Early return so we skip the expensive report_state()
|
|
// call. It is OK to skip it because we are bound to report
|
|
// our state once the excange acknowledges the order.
|
|
update_working_position();
|
|
return OrderOpResult{};
|
|
} else {
|
|
report_state();
|
|
return result;
|
|
}
|
|
}
|
|
// control will only reach here if on_init_new failed, or it was a
|
|
// recovered order, in which case we are already in a terminal state,
|
|
// hence nothing to
|
|
default:
|
|
bts_assert(in_terminal_state(me->state.status()));
|
|
break;
|
|
}
|
|
report_state();
|
|
return result;
|
|
}
|
|
|
|
OrderOpResult EMNativeOrder::on_update(Price p, Quantity q) {
|
|
LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} p: {} q: {}",
|
|
key().value(), p, q);
|
|
api::orderman::Update update;
|
|
update.set_price(p.value());
|
|
update.set_quantity(q.value());
|
|
update.mutable_fractional_quantity()->set_fraction(q.fractional_part());
|
|
return on_update(update);
|
|
}
|
|
|
|
OrderOpResult EMNativeOrder::on_update(api::orderman::Update const &update) {
|
|
LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} update: {}",
|
|
key().value(), utils::pb::to_string(update));
|
|
auto new_p = Price(update.price());
|
|
auto new_q = bts::orderman::get_update_quantity(update);
|
|
LOG(OrderMan, Info, "EMNativeOrder on_update update key: {} p: {} q: {}",
|
|
key().value(), new_p, new_q);
|
|
auto result = OrderOpResult{};
|
|
// the only state where we consider an update is ORDER_STATUS_WORKING
|
|
switch (me->state.status()) {
|
|
case ORDER_STATUS_WORKING: {
|
|
auto curr_working_qty = working_position();
|
|
auto potential_working_qty = 0;
|
|
if (new_q.value() > me->state.filled_quantity())
|
|
potential_working_qty = new_q.value() - me->state.filled_quantity();
|
|
auto lqr = me->services->limiter().can_update_order(
|
|
AccountID(me->definition.account_id()), *me->sec,
|
|
me->definition.side(), Quantity(curr_working_qty),
|
|
Quantity(potential_working_qty));
|
|
lqr.result = Limiter::OK;
|
|
// are we under the position limits?
|
|
if (!lqr.ok()) {
|
|
auto msg = fmt::format(
|
|
"Cannot update order due to limit breach: {}", lqr.error_msg);
|
|
LOG(OrderMan, Error,
|
|
"Order update failed due to limit breach. Order: {} Msg: {}",
|
|
key().value(), lqr.error_msg);
|
|
ignore_or_cancel(msg, ORDER_ERROR_LIMIT_BREACH, &result);
|
|
break;
|
|
}
|
|
// are we under the messaging threshold?
|
|
if (!me->services->governor(*me->session_services).can_send()) {
|
|
LOG(OrderMan, Warn,
|
|
"Cannot update order {} because of messaging limits. ",
|
|
key().value());
|
|
auto msg = "Messaging threshold breached";
|
|
ignore_or_cancel(msg, ORDER_ERROR_MESSAGING_LIMIT_BREACH, &result);
|
|
break;
|
|
}
|
|
CancelReplaceOrderMsg cxl_repl_msg = {};
|
|
_create_create_msg(cxl_repl_msg.create_fields);
|
|
cxl_repl_msg.create_fields.price = new_p;
|
|
cxl_repl_msg.create_fields.quantity = new_q;
|
|
me->services->queue_order_msg(*me->session_services, cxl_repl_msg);
|
|
me->services->governor(*me->session_services).record_sent();
|
|
update_working_position();
|
|
if (me->state.last_msg().size())
|
|
me->state.set_last_msg("");
|
|
// early return so we skip report_state (for speed) (an execution
|
|
// report should take care of it?)
|
|
return OrderOpResult{};
|
|
}
|
|
// anytime we disconnect we go to error and let the execution gwy take
|
|
// care of it
|
|
case ORDER_STATUS_DISCONNECTED:
|
|
bts_assert(false);
|
|
break;
|
|
case ORDER_STATUS_PENDING_WORKING:
|
|
LOG(OrderMan, Warn,
|
|
"Cannot apply update to order {}. Update: {}@{}. Buffering",
|
|
key().value(), update.quantity(), update.price());
|
|
me->buffered_update.emplace(update);
|
|
break;
|
|
// terminal states, nothing to do
|
|
case ORDER_STATUS_REJECTED_BY_SPARK:
|
|
case ORDER_STATUS_COMPLETED:
|
|
case ORDER_STATUS_CANCELED:
|
|
case ORDER_STATUS_ERROR:
|
|
break;
|
|
case ORDER_STATUS_INACTIVE:
|
|
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
|
|
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
|
|
bts_assert(false);
|
|
break;
|
|
}
|
|
report_state();
|
|
return result;
|
|
}
|
|
|
|
OrderOpResult EMNativeOrder::on_detach() { return {}; }
|
|
|
|
OrderOpResult EMNativeOrder::on_cancel() {
|
|
LOG(OrderMan, Info, "EMNativeOrder::on_cancel key: {}", key());
|
|
auto result = OrderOpResult{};
|
|
switch (me->state.status()) {
|
|
// the only state where a cancel is sent out
|
|
case ORDER_STATUS_WORKING: {
|
|
// TODO, CancelOrderMsg is not completely filled
|
|
CancelOrderMsg cxl_msg = {};
|
|
cxl_msg.key = key();
|
|
LOG(OrderMan, Info, "EMNativeOrder queue_order_msg for cxl");
|
|
me->services->queue_order_msg(*me->session_services, cxl_msg);
|
|
break;
|
|
}
|
|
// already in a terminal state, nothing to do
|
|
case ORDER_STATUS_CANCELED:
|
|
case ORDER_STATUS_REJECTED_BY_SPARK:
|
|
case ORDER_STATUS_COMPLETED:
|
|
case ORDER_STATUS_ERROR:
|
|
break;
|
|
case ORDER_STATUS_PENDING_WORKING: {
|
|
// we buffer this, and as soon as we get the exchnage id, we cxl it
|
|
me->buffered_cancel = true;
|
|
LOG(OrderMan, Warn,
|
|
"Cannot cancel order {} while in the pending working state. "
|
|
"Buffering cancel",
|
|
key().value());
|
|
break;
|
|
}
|
|
case ORDER_STATUS_DISCONNECTED: {
|
|
me->buffered_cancel = true;
|
|
LOG(OrderMan, Warn,
|
|
"Cannot cancel order {} while in the disconnected state. "
|
|
"Buffering "
|
|
"cancel",
|
|
key().value());
|
|
auto msg = "Order will be canceled when re-connected";
|
|
result.error = ORDER_ERROR_GATEWAY_NOT_READY;
|
|
result.error_msg = msg;
|
|
// to print the message
|
|
transition(me->state.status(), msg);
|
|
break;
|
|
}
|
|
case ORDER_STATUS_INACTIVE:
|
|
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
|
|
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
|
|
bts_assert(false);
|
|
break;
|
|
}
|
|
report_state();
|
|
return result;
|
|
}
|
|
|
|
void EMNativeOrder::on_attached(api::orderman::OrderDefinition const &) {
|
|
// TODO
|
|
}
|
|
|
|
api::orderman::OrderDefinition EMNativeOrder::on_init_from_exe_report(
|
|
ExecutionReport const &, const PreActivationOrderServices &) {
|
|
// TODO
|
|
return me->definition;
|
|
}
|
|
|
|
void EMNativeOrder::warm_up_activate(OrderServicesData &, OrderServices &) {}
|
|
|
|
void EMNativeOrder::transition(
|
|
api::orderman::OrderStatus new_status, std::string const &msg) {
|
|
transition(Info, new_status, msg);
|
|
}
|
|
|
|
void EMNativeOrder::transition(
|
|
log::Level level,
|
|
api::orderman::OrderStatus new_status,
|
|
std::string const &msg) {
|
|
auto const &from = OrderStatus_Name(me->state.status());
|
|
auto const &to = OrderStatus_Name(new_status);
|
|
if (from != to)
|
|
LOG(OrderMan, level, "Transitioning order {} from {} to {}. Msg: {}",
|
|
key().value(), from, to, msg);
|
|
me->state.set_status(new_status);
|
|
me->state.set_last_msg(msg);
|
|
}
|
|
|
|
void EMNativeOrder::transition(api::orderman::OrderStatus new_status) {
|
|
auto const &from = OrderStatus_Name(me->state.status());
|
|
auto const &to = OrderStatus_Name(new_status);
|
|
if (from != to)
|
|
LOG(OrderMan, Info, "Transitioning order {} from {} to {}", key().value(),
|
|
from, to);
|
|
else
|
|
LOG(OrderMan, Diag, "Transitioning order {} from {} to {}", key().value(),
|
|
from, to);
|
|
me->state.set_status(new_status);
|
|
}
|
|
|
|
void EMNativeOrder::update_working_position() {
|
|
if (me->sec) {
|
|
auto current_position = working_position();
|
|
auto previous_position = me->previous_working_position;
|
|
me->previous_working_position = current_position;
|
|
|
|
if (current_position.value() > previous_position.value())
|
|
me->services->limiter().add_to_working_position(
|
|
*me->sec, AccountID(me->definition.account_id()),
|
|
me->definition.side(),
|
|
Quantity(current_position.value() - previous_position.value()));
|
|
else if (previous_position.value() > current_position.value())
|
|
me->services->limiter().remove_from_working_position(
|
|
*me->sec, AccountID(me->definition.account_id()),
|
|
me->definition.side(),
|
|
Quantity(previous_position.value() - current_position.value()));
|
|
} else
|
|
LOG(OrderMan, Error,
|
|
"Order {} ignored for purposes of limit enforcing "
|
|
"because it references unknown security {} ",
|
|
key().value(), me->definition.security_key());
|
|
}
|
|
|
|
// Returns the open position for a working order. If there are fills,
|
|
// returns the difference
|
|
Quantity EMNativeOrder::working_position() {
|
|
switch (me->state.status()) {
|
|
// working
|
|
case ORDER_STATUS_WORKING:
|
|
case ORDER_STATUS_PENDING_WORKING:
|
|
case ORDER_STATUS_DISCONNECTED:
|
|
if (me->state.quantity() > me->state.filled_quantity())
|
|
return Quantity(me->state.quantity() - me->state.filled_quantity());
|
|
else
|
|
return Quantity(0);
|
|
// terminal
|
|
case ORDER_STATUS_REJECTED_BY_SPARK:
|
|
case ORDER_STATUS_ERROR:
|
|
case ORDER_STATUS_COMPLETED:
|
|
case ORDER_STATUS_CANCELED:
|
|
return Quantity(0);
|
|
|
|
case ORDER_STATUS_INACTIVE:
|
|
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
|
|
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
|
|
bts_assert(false);
|
|
return Quantity(0);
|
|
}
|
|
bts_assert(false);
|
|
return Quantity(0);
|
|
}
|
|
|
|
void EMNativeOrder::report_state() {
|
|
update_working_position();
|
|
LOG(OrderMan, Info, "EMNativeOrder::report_state state: {}",
|
|
utils::pb::to_string(me->state));
|
|
me->services->report_state(me->state);
|
|
}
|
|
|
|
OrderOpResult EMNativeOrder::_on_activate(
|
|
log::Level reject_level,
|
|
log::Level transition_level,
|
|
Price p,
|
|
Quantity q,
|
|
bts::orderman::OrderServices &
|
|
/*order_services*/) {
|
|
LOG(OrderMan, Info, "EMNativeOrder::_on_activate p: {} q: {}", p, q);
|
|
// update state wrt price, qty, fills
|
|
me->state.set_price(p.value());
|
|
bts::orderman::set_quantity(me->state, StateQuantityType::OrderQuantity, q);
|
|
me->state.set_filled_quantity(0);
|
|
me->state.set_last_price(0);
|
|
me->state.set_avg_price(0);
|
|
|
|
me->session_services = &me->services->get_session_services(
|
|
get_native_state(me->state).routing_record().session());
|
|
// TODO: just to get going
|
|
me->session_services = &me->services->get_session_services("deribit_em");
|
|
|
|
// Checks for the following:
|
|
// 1. Gateway connection
|
|
// 2. Risk (can_trade, clip, position)
|
|
// 3. Governor (orders/sec)
|
|
// If any of the above fail, it goes to terminal state
|
|
// (ORDER_STATUS_REJECTED_BY_SPARK) abd returns error
|
|
// Else, subscribes to service events (including execution report)
|
|
if (!_is_gateway_connected(me->session_services)) {
|
|
LOG(OrderMan, reject_level,
|
|
"Attempt to send order to a disconnected gateway. "
|
|
"Dropping order {}",
|
|
key().value());
|
|
auto msg = "Exchange gateway is down";
|
|
transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return OrderOpResult{ORDER_ERROR_GATEWAY_NOT_READY, msg};
|
|
}
|
|
// this is to skip risk limits for options
|
|
bool turn_risk_off =
|
|
false; // me->sec->has_option() || me->sec->has_future();
|
|
// the following consults the limiter
|
|
// can the user trade ?
|
|
auto lqr = me->services->limiter().can_trade(
|
|
UserID(me->definition.user_id()),
|
|
AccountID(me->definition.account_id()));
|
|
if (turn_risk_off) {
|
|
lqr.result = Limiter::LimiterErrorCode::OK;
|
|
}
|
|
if (!lqr.ok()) {
|
|
LOG(OrderMan, reject_level,
|
|
"Unauthorized order attempted. User: {} on "
|
|
"Account: {}. Msg: {} Order: {}. Dropping order",
|
|
me->definition.user(), me->definition.account(), lqr.error_msg,
|
|
key().value());
|
|
auto msg = fmt::format("Unauthorized order: {}", lqr.error_msg);
|
|
transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return OrderOpResult{ORDER_ERROR_UNAUTHORIZED, msg};
|
|
}
|
|
// risk limits (clip size, position)
|
|
lqr = me->services->limiter().can_send_new_order(
|
|
AccountID(me->definition.account_id()), *me->sec, me->definition.side(),
|
|
q);
|
|
if (turn_risk_off) {
|
|
lqr.result = Limiter::LimiterErrorCode::OK;
|
|
}
|
|
if (!lqr.ok()) {
|
|
LOG(OrderMan, reject_level,
|
|
"New order would breach limit. User: {} Account: "
|
|
"{} Msg: {} Order: {}. Dropping order",
|
|
me->definition.user(), me->definition.account(), lqr.error_msg,
|
|
key().value());
|
|
auto msg = fmt::format("Order would breach limit: {}", lqr.error_msg);
|
|
transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return OrderOpResult{ORDER_ERROR_LIMIT_BREACH, msg};
|
|
}
|
|
|
|
// are we under the messaging threshold? (governor limits)
|
|
if (!me->services->governor(*me->session_services).can_send()) {
|
|
LOG(OrderMan, reject_level,
|
|
"New order would cause breach of messaging "
|
|
"limits. Dropping order {}",
|
|
key().value());
|
|
auto msg = "Messaging threshold breached";
|
|
transition(transition_level, ORDER_STATUS_REJECTED_BY_SPARK, msg);
|
|
return OrderOpResult(ORDER_ERROR_MESSAGING_LIMIT_BREACH, msg);
|
|
}
|
|
|
|
me->exe_report_sid = me->services->subscribe_to_exe_report(
|
|
*me->session_services, key(),
|
|
[this](auto const &r) { this->_on_exe_report(r); });
|
|
me->cancel_reject_sid = me->services->subscribe_to_cancel_reject(
|
|
*me->session_services, key(), [this](auto const &cr) {
|
|
LOG(OrderMan, Error, "CancelReject received for order: {} msg: {}",
|
|
key(), cr.reject_msg());
|
|
});
|
|
me->services->subscribe_to_gateway_status(
|
|
*me->session_services, [this](auto const &gw) {
|
|
// gateway will cancel all orders
|
|
if (!gw.is_connected) {
|
|
transition(
|
|
api::orderman::OrderStatus::ORDER_STATUS_ERROR,
|
|
"Connection to gateway lost");
|
|
report_state();
|
|
}
|
|
});
|
|
|
|
LOG(OrderMan, Info, "EMNativeOrder::_on_activate sucessful key: {}", key());
|
|
LOG(OrderMan, Info, "EMNativeOrder::_on_activate state: {}",
|
|
utils::pb::to_string(me->state));
|
|
return OrderOpResult{};
|
|
}
|
|
|
|
// OrderState's CustomOrderState has some OrderStates' corresponding to
|
|
// NativeOrder (ex MarketOrderState, LimitOrderState etc). Each of these
|
|
// special OrderStates have NativeOrderState - this function plucks that out
|
|
api::orderman::NativeOrderState &EMNativeOrder::get_native_state(
|
|
api::orderman::OrderState &st) {
|
|
switch (st.custom_case()) {
|
|
case OrderState::kMarket:
|
|
return *st.mutable_market()->mutable_native_state();
|
|
case OrderState::kLimit:
|
|
return *st.mutable_limit()->mutable_native_state();
|
|
default:
|
|
break;
|
|
}
|
|
bts_assert(false);
|
|
return *st.mutable_limit()->mutable_native_state();
|
|
}
|
|
|
|
NativeOrderType get_native_ord_type(const OrderDefinition &def) {
|
|
switch (def.custom_def().custom_case()) {
|
|
case CustomOrderDefinition::kMarket:
|
|
return NativeOrderType::NATIVE_ORDER_TYPE_MARKET;
|
|
break;
|
|
case CustomOrderDefinition::kLimit:
|
|
return NativeOrderType::NATIVE_ORDER_TYPE_LIMIT;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
bts_assert(false);
|
|
return api::orderman::NATIVE_ORDER_TYPE_LIMIT;
|
|
}
|
|
|
|
void EMNativeOrder::_create_create_msg(CreateOrderMsg &c) {
|
|
c.key = key();
|
|
c.price = Price(me->state.price());
|
|
c.quantity =
|
|
bts::orderman::get_quantity(me->state, StateQuantityType::OrderQuantity);
|
|
c.security = me->sec;
|
|
c.side = me->definition.side();
|
|
c.order_type = get_native_ord_type(me->definition);
|
|
c.time_in_force = me->definition.time_in_force();
|
|
c.order_type = api::orderman::NATIVE_ORDER_TYPE_LIMIT;
|
|
c.manual_order_indicator = me->definition.manual_order_indicator();
|
|
c.routing_record = &me->routing_record;
|
|
LOG(OrderMan, Info, "EMNativeOrder::_create_create_msg c.qty: {}",
|
|
c.quantity);
|
|
}
|
|
|
|
void EMNativeOrder::_on_exe_report(const NewExecutionReportEvent &er) {
|
|
LOG(OrderMan, Info, "EMNativeOrder::_on_exe_report key: {} er: {}", key(),
|
|
er.data->to_string());
|
|
auto &state = me->state;
|
|
// we dont care for the native status in EM, for backwards compatibility's
|
|
// sake updating it
|
|
auto &native_state = get_native_state(state);
|
|
native_state.set_last_msg_seq_num(er.data->msg_seq_num);
|
|
native_state.set_native_status(er.data->order_status);
|
|
native_state.set_native_type(er.data->order_type);
|
|
set_last_transact_time(er.data->transact_time, &native_state);
|
|
// This status is inferred from the er
|
|
OrderStatus er_status = get_external_status(er.data->order_status);
|
|
bts_assert(
|
|
er_status == OrderStatus::ORDER_STATUS_WORKING ||
|
|
er_status == OrderStatus::ORDER_STATUS_CANCELED ||
|
|
er_status == OrderStatus::ORDER_STATUS_COMPLETED ||
|
|
er_status == OrderStatus::ORDER_STATUS_ERROR);
|
|
state.set_last_msg(er.data->msg);
|
|
auto _absorb_er = [this, &er, &er_status]() {
|
|
// this is not set in on_update, but only set when the exchange ack's it
|
|
me->state.set_price(er.data->price.value());
|
|
// me->state.set_quantity(er.data->quantity.value());
|
|
bts::orderman::set_quantity(
|
|
me->state, StateQuantityType::OrderQuantity, er.data->quantity);
|
|
_absorb_fill(*er.data);
|
|
transition(er_status);
|
|
};
|
|
switch (me->state.status()) {
|
|
case api::orderman::ORDER_STATUS_INACTIVE:
|
|
// as soon an order is sent we leave this state, so there is no way we
|
|
// should get an er while in this state
|
|
bts_assert(false);
|
|
break;
|
|
// terminal state already, nothing to do
|
|
case ORDER_STATUS_COMPLETED:
|
|
case ORDER_STATUS_CANCELED:
|
|
case ORDER_STATUS_ERROR:
|
|
LOG(OrderMan, Error,
|
|
"Received er: {} for key: {} while in terminal state",
|
|
er.data->to_string(), key());
|
|
break;
|
|
// the only 2 states that handle execution report are
|
|
// ORDER_STATUS_WORKING and ORDER_STATUS_PENDING_WORKING
|
|
case api::orderman::ORDER_STATUS_WORKING:
|
|
_absorb_er();
|
|
break;
|
|
case ORDER_STATUS_PENDING_WORKING:
|
|
_absorb_er();
|
|
if (in_terminal_state(er_status)) {
|
|
break;
|
|
}
|
|
bts_assert(er_status == OrderStatus::ORDER_STATUS_WORKING);
|
|
if (me->buffered_cancel) {
|
|
LOG(OrderMan, Warn,
|
|
"Applying buffered cancel to order {}, on first ack",
|
|
key().value());
|
|
on_cancel();
|
|
} else if (me->buffered_update.has_value()) {
|
|
auto update = me->buffered_update.value();
|
|
me->buffered_update.reset();
|
|
LOG(OrderMan, Warn,
|
|
"Applying buffered update ({}@{}) to order {}, on "
|
|
"first ack",
|
|
update.quantity(), update.price(), key().value());
|
|
on_update(update);
|
|
}
|
|
break;
|
|
case ORDER_STATUS_DISCONNECTED: // will never be in this state
|
|
case ORDER_STATUS_REJECTED_BY_SPARK:
|
|
// it only gets rejected before the order is sent, so similiar to
|
|
// inactive, we should never get an er here
|
|
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
|
|
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
|
|
bts_assert(false);
|
|
break;
|
|
}
|
|
report_state();
|
|
}
|
|
|
|
bool EMNativeOrder::_is_gateway_connected(SessionServices *) const {
|
|
return true;
|
|
}
|
|
|
|
void EMNativeOrder::ignore_or_cancel(
|
|
std::string const &msg,
|
|
api::orderman::OrderError error,
|
|
OrderOpResult *out) {
|
|
if (parent_key() == null_order_key())
|
|
transition(me->state.status(), msg);
|
|
else {
|
|
me->state.set_last_msg(msg);
|
|
on_cancel();
|
|
}
|
|
*out = {error, msg};
|
|
}
|
|
|
|
Quantity EMNativeOrder::_working_qty() const {
|
|
auto rv = Quantity(0);
|
|
if (me->state.quantity() > me->state.filled_quantity()) {
|
|
rv = Quantity(me->state.quantity() - me->state.filled_quantity());
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
void EMNativeOrder::_absorb_fill(const ExecutionReport &er) {
|
|
if (er.last_shares > Quantity(0, 0)) {
|
|
bts::orderman::set_quantity(
|
|
me->state, StateQuantityType::FilledQuantity, er.filled_quantity);
|
|
me->state.set_avg_price(er.avg_price.value());
|
|
me->state.set_last_price(er.last_price.value());
|
|
}
|
|
}
|
|
|
|
} // namespace orderman
|
|
} // namespace bts
|