add, update, remove orders work across logouts

This commit is contained in:
Kevin Darby committed 2019-04-25 15:25:07 -04:00
1 parent caa9671c96
commit 4cbbf6972a
6 files changed
+150 -103

No files matched your search

+1 -1
View File
@@ -165,7 +165,7 @@ public:
void read (ReaderCursor &cursor)
{
auto loc = cursor.read_field ();
Parent::_value = atoi (&(cursor.data ()[loc.first]));
Parent::_value = atoll (&(cursor.data ()[loc.first]));
}
static uint32_t max_value_size (int64_t,int pad = 0)
@@ -251,7 +251,16 @@ void ICEExecutionGateway::on_exe_report(const jetfix::fix::ICEExecutionReportMsg
{
OrderKey ok;
SecurityKey sk;
decode_memo(msg.get<fix::Memo>(), &ok, &sk);
if(!msg.has<fix::Memo>())
{
LOG(OrderMan, Error,
"Received execution report with no memo {}. Will not be able to process this report. This is likely a bug that could lead "
"to lost fills. Please investigate.",
sk.value());
return;
}
else
decode_memo(msg.get<fix::Memo>(), &ok, &sk);
auto scoped_log = trace::log_scope(me->perf_log, msg.trace(), "ICEExecutionGateway::on_exe_report", ok.value());
@@ -348,6 +357,9 @@ void ICEExecutionGateway::on_exe_report(const jetfix::fix::ICEExecutionReportMsg
std::string oid_string = get_ice_order_id_string(msg);
str_to(oid_string, &data->exchange_order_id);
data->ice_cl_ord_id = 0;
if(msg.has<fix::Int_ClOrdID>())
data->ice_cl_ord_id = msg.get<fix::Int_ClOrdID>();
if (msg.has<fix::Price>())
data->price = securities::decode_exchange_price(*sec, Price(msg.get<fix::Price>()));
@@ -35,6 +35,7 @@ public:
config::JetFIX::Connection const *cfg;
std::string msg;
api::Venue exchange;
int64_t ice_cl_ord_id;
};
}}
@@ -74,9 +74,21 @@ std::string get_ice_order_id_string(const MSG& msg)
bts_assert(msg.template has<jetfix::fix::Int_OrderID>());
std::string oid_string(ice_orderid_sz(), ' ');
int id = msg.template get<jetfix::fix::Int_OrderID>();
u32_toa((uint32_t)id, &(oid_string[0]), ice_orderid_sz() );
int64_t id = msg.template get<jetfix::fix::Int_OrderID>();
u64_toa(id, &(oid_string[0]), ice_orderid_sz() );
return oid_string;
}
template <class MSG>
std::string get_ice_clord_id_string(const MSG& msg)
{
bts_assert(msg.template has<jetfix::fix::Int_ClOrdID>());
std::string oid_string(ice_orderid_sz(), ' ');
int64_t id = msg.template get<jetfix::fix::Int_ClOrdID>();
u64_toa(id, &(oid_string[0]), ice_orderid_sz() );
return oid_string;
}
}}
+106 -88
View File
@@ -13,6 +13,7 @@
#include "lib/orderman/securities/ISecurityDB.h"
#include "lib/md/IntPrice.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/Puid.h"
#include "lib/utils/bts_chrono.h"
#include "lib/orderman/actors/order_manager/OrderServices.h"
@@ -20,6 +21,7 @@
#include <algorithm>
#include <math.h>
#include <sys/time.h>
#include <queue>
namespace bts {
namespace orderman {
@@ -33,7 +35,8 @@ struct ICENativeOrder::PImpl
PImpl()
: services(nullptr), session_services(), sec(nullptr),
previous_position_contribution(0), definition(), state(),
price_encoding_precision(7), exchange_order_id() {
price_encoding_precision(7), exchange_order_id(), update_clordid_queue(), cancel_clordid_queue()
{
exchange_order_id.reserve(100);
}
@@ -48,13 +51,15 @@ struct ICENativeOrder::PImpl
int price_encoding_precision;
std::string exchange_order_id;
int sender_compid;
uint64_t id_scale, update_scale, cancel_scale;
uint64_t id_scale, orig_clordid;
std::queue<uint64_t> update_clordid_queue, cancel_clordid_queue;
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::Bookmark<jetfix::fix::Int_ClOrdID> update_clordid_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_OrigClOrdID> update_orig_clordid_bm;
jetfix::FIXFragment create_encoding;
jetfix::FIXFragment::Bookmark<jetfix::fix::Price> create_price_bm;
@@ -63,6 +68,7 @@ struct ICENativeOrder::PImpl
jetfix::FIXFragment cancel_encoding;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_ClOrdID> cancel_clordid_bm;
jetfix::FIXFragment::Bookmark<jetfix::fix::Int_OrigClOrdID> cancel_orig_clordid_bm;
OrderServices::ExeReportSubID exe_report_sid;
OrderServices::CancelRejectSubID cancel_reject_sid;
@@ -129,17 +135,17 @@ void ICENativeOrder::on_init_new(const OrderDefinition& def, const PreActivation
}
}
void ICENativeOrder::on_init_recovered(const OrderRecord& rec, const PreActivationOrderServices& serv)
void ICENativeOrder::init_recovered_common(const api::orderman::OrderRecord& rec, const PreActivationOrderServices& serv)
{
// order was recovered from our orders database or from an execution report
auto const &def = rec.def();
const auto &def = rec.def();
me->definition = def;
me->state = rec.state();
me->sec = serv.sec_db.resolve(SecurityKey(def.security_key()));
me->previous_position_contribution = Quantity(rec.state().filled_quantity());
auto const &native_state = get_native_state(me->state);
const auto &native_state = get_native_state(me->state);
setup_ids(native_state.routing_record().sender_compid());
switch (me->state.status())
{
@@ -160,7 +166,7 @@ void ICENativeOrder::on_init_recovered(const OrderRecord& rec, const PreActivati
}
// bail if the session we used for the order is no longer valid
auto const &session = native_state.routing_record().session();
const auto &session = native_state.routing_record().session();
if (!serv.order_router.is_valid_session(session))
{
LOG(OrderMan, Error,
@@ -194,7 +200,16 @@ void ICENativeOrder::on_init_recovered(const OrderRecord& rec, const PreActivati
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
return;
}
}
}
void ICENativeOrder::on_init_recovered(const OrderRecord& rec, const PreActivationOrderServices& serv)
{
//TODO need to figure out if this is a day order from a prev session and cancel it
// const auto &def = rec.def();
// auto &state = *orecord.mutable_state();
// state.set_status(map_external_status(api::orderman::NativeOrderStatus::NATIVE_ORDER_STATUS_CANCELED);
init_recovered_common(rec, serv);
}
api::orderman::OrderDefinition
@@ -290,7 +305,7 @@ ICENativeOrder::on_init_from_exe_report(const ExecutionReport& er, const PreActi
rr.set_cti_code(CTICode(er.cfg->cti_code()[0]));
rr.set_customer_or_firm(CustomerOrFirm(er.cfg->customer_or_firm()));
rr.set_location(er.cfg->sender_locationid());
on_init_recovered(orecord, os);
init_recovered_common(orecord, os);
return orecord.def();
}
@@ -313,10 +328,8 @@ void ICENativeOrder::warm_up_activate(OrderServicesData &data, OrderServices &se
me->state.set_status(before_state);
me->state.set_last_msg(before_msg);
me->services->unsubscribe_from_exe_report(*me->session_services,
me->exe_report_sid);
me->services->unsubscribe_from_cancel_reject(*me->session_services,
me->cancel_reject_sid);
me->services->unsubscribe_from_exe_report(*me->session_services, me->exe_report_sid);
me->services->unsubscribe_from_cancel_reject(*me->session_services, me->cancel_reject_sid);
me->services->unsubscribe_from_gateway_status(*me->session_services);
me->services = nullptr;
}
@@ -338,8 +351,7 @@ ICENativeOrder::_on_activate(log::Level reject_level, log::Level transition_leve
if (!me->services->is_gateway_connected(*me->session_services))
{
LOG(OrderMan, reject_level,
"Attempt to send order to a disconnected gateway. "
"Dropping order {}",
"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);
@@ -362,8 +374,7 @@ ICENativeOrder::_on_activate(log::Level reject_level, log::Level transition_leve
}
// 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);
lqr = me->services->limiter().can_send_new_order( AccountID(me->definition.account_id()), *me->sec, me->definition.side(), q );
if (!lqr.ok)
{
@@ -378,12 +389,11 @@ ICENativeOrder::_on_activate(log::Level reject_level, log::Level transition_leve
return OrderOpResult{ORDER_ERROR_LIMIT_BREACH, msg};
}
// are we under the messaging threshold?
// are we under the messaging threshold? TODO
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());
"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);
@@ -392,11 +402,11 @@ ICENativeOrder::_on_activate(log::Level reject_level, log::Level transition_leve
// if we are here we are good.
// subscribe to usefull events
me->exe_report_sid = me->services->subscribe_to_exe_report(*me->session_services, key(),
[this](auto const &r) { this->on_exe_report(r); });
[this](const auto &r) { this->on_exe_report(r); });
me->cancel_reject_sid = me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](auto const &cr) { this->on_cancel_reject(cr); });
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](auto const &gw) { this->on_gateway_status(gw); });
[this](const auto &gw) { this->on_gateway_status(gw); });
// send out order
auto &encoding = me->create_encoding;
@@ -420,20 +430,18 @@ ICENativeOrder::_on_activate(log::Level reject_level, log::Level transition_leve
}
me->create_quantity_bm = encoding.overwrite(me->create_quantity_bm, q.value(), quantity_sz());
auto const &ts = services.get_time_str();
const auto &ts = services.get_time_str();
me->create_transact_time_bm = encoding.overwrite(me->create_transact_time_bm, &ts.value()[0], ts.value().size());
return OrderOpResult{};
}
OrderOpResult ICENativeOrder::on_activate(Price p, Quantity q,
bts::orderman::OrderServices &services)
OrderOpResult ICENativeOrder::on_activate(Price p, Quantity q, bts::orderman::OrderServices &services)
{
bts_assert(!me->services);
me->services = &services;
auto result = OrderOpResult{};
switch (me->state.status())
{
case ORDER_STATUS_INACTIVE:
{
auto scoped_log = services.log_scope("ICENativeOrder::on_activate", key().value());
@@ -442,10 +450,7 @@ OrderOpResult ICENativeOrder::on_activate(Price p, Quantity q,
result = _on_activate(Warn, Info, p, q, services);
if (result.ok())
{
me->services->queue_fix(*me->session_services,
jetfix::MessageTypes::NewOrderSingle,
me->create_encoding);
me->services->queue_fix(*me->session_services, jetfix::MessageTypes::NewOrderSingle, me->create_encoding);
me->services->governor(*me->session_services).record_sent();
me->state.set_status(ORDER_STATUS_PENDING_WORKING);
@@ -465,11 +470,11 @@ OrderOpResult ICENativeOrder::on_activate(Price p, Quantity q,
case ORDER_STATUS_WORKING:
me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session() );
me->services->subscribe_to_exe_report(*me->session_services, key(),
[this](auto const &r) { this->on_exe_report(r); });
[this](const auto &r) { this->on_exe_report(r); });
me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](auto const &cr) { this->on_cancel_reject(cr); });
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](auto const &gw) { this->on_gateway_status(gw); });
[this](const auto &gw) { this->on_gateway_status(gw); });
if (!me->services->is_gateway_connected(*me->session_services))
{
@@ -482,11 +487,11 @@ OrderOpResult ICENativeOrder::on_activate(Price p, Quantity q,
case ORDER_STATUS_DISCONNECTED:
me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session() );
me->services->subscribe_to_exe_report(*me->session_services, key(),
[this](auto const &r) { this->on_exe_report(r); });
[this](const auto &r) { this->on_exe_report(r); });
me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](auto const &cr) { this->on_cancel_reject(cr); });
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](auto const &gw) { this->on_gateway_status(gw); });
[this](const auto &gw) { this->on_gateway_status(gw); });
if (me->services->is_gateway_connected(*me->session_services))
transition(ORDER_STATUS_WORKING);
@@ -495,11 +500,11 @@ OrderOpResult ICENativeOrder::on_activate(Price p, Quantity q,
case ORDER_STATUS_PENDING_WORKING:
me->session_services = &me->services->get_session_services( get_native_state(me->state).routing_record().session() );
me->services->subscribe_to_exe_report(*me->session_services, key(),
[this](auto const &r) { this->on_exe_report(r); });
[this](const auto &r) { this->on_exe_report(r); });
me->services->subscribe_to_cancel_reject(*me->session_services, key(),
[this](auto const &cr) { this->on_cancel_reject(cr); });
[this](const auto &cr) { this->on_cancel_reject(cr); });
me->services->subscribe_to_gateway_status(*me->session_services,
[this](auto const &gw) { this->on_gateway_status(gw); });
[this](const auto &gw) { this->on_gateway_status(gw); });
break;
case ORDER_STATUS_REJECTED_BY_SPARK:
@@ -586,16 +591,20 @@ OrderOpResult ICENativeOrder::on_update(Price p, Quantity q)
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() );
const auto &ts = me->services->get_time_str();
me->update_transact_time_bm = encoding.overwrite( me->update_transact_time_bm, &ts.value()[0], ts.value().size() );
auto update_clordid = get_clordid(me->update_scale + key().value());
me->update_clordid_bm = encoding.overwrite( me->update_clordid_bm, update_clordid, count_digits(update_clordid) );
me->services->queue_fix(*me->session_services,
jetfix::MessageTypes::CancelReplace,
me->update_encoding);
if(me->update_clordid_queue.empty())
{
generate_update_ids();
LOG(OrderMan, Warn, "Update order slow {} because of we are out of clordids. ", key().value());
}
auto update_clorid = get_clordid(me->update_clordid_queue.front());
me->update_clordid_queue.pop();
me->update_clordid_bm = encoding.overwrite( me->update_clordid_bm, update_clorid, count_digits(update_clorid) );
me->services->queue_fix(*me->session_services, jetfix::MessageTypes::CancelReplace, me->update_encoding);
me->services->governor(*me->session_services).record_sent();
update_working_position();
if (me->state.last_msg().size())
@@ -701,12 +710,17 @@ OrderOpResult ICENativeOrder::on_cancel()
case ORDER_STATUS_WORKING:
{
auto &encoding = me->cancel_encoding;
auto cancel_clordid = get_clordid(me->cancel_scale + key().value());
me->cancel_clordid_bm = encoding.overwrite( me->cancel_clordid_bm, cancel_clordid, count_digits(cancel_clordid) );
me->services->queue_fix(*me->session_services,
jetfix::MessageTypes::Cancel,
me->cancel_encoding);
if(me->cancel_clordid_queue.empty())
{
generate_update_ids();
LOG(OrderMan, Error, "Cancel order slow {} because of we are out of clordids.", key().value());
}
auto cancel_clorid = get_clordid(me->cancel_clordid_queue.front());
me->cancel_clordid_queue.pop();
me->cancel_clordid_bm = encoding.overwrite( me->cancel_clordid_bm, cancel_clorid, count_digits(cancel_clorid) );
me->services->queue_fix(*me->session_services, jetfix::MessageTypes::Cancel,me->cancel_encoding);
break;
}
@@ -798,27 +812,18 @@ void ICENativeOrder::on_exe_report(const NewExecutionReportEvent &er)
native_state.set_last_transact_time(to_str(er.data->transact_time));
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) //TODO
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_avg_price(er.data->avg_price.value());
state.set_filled_quantity(er.data->filled_quantity.value());
state.set_last_price(er.data->last_price.value());
//cache the new clordid
if(er.data->ice_cl_ord_id > 0)
{
auto clordid = er.data->ice_cl_ord_id;
me->update_orig_clordid_bm = me->update_encoding.overwrite( me->update_orig_clordid_bm, clordid, count_digits(clordid) );
me->cancel_orig_clordid_bm = me->cancel_encoding.overwrite( me->cancel_orig_clordid_bm, clordid, count_digits(clordid) );
}
}
state.set_last_msg(er.data->msg);
@@ -947,7 +952,7 @@ void ICENativeOrder::on_gateway_status(const GatewayStatusChangeEvent &ev)
break;
case ORDER_STATUS_DISCONNECTED:
{
auto const &native_state = get_native_state(me->state);
const auto &native_state = get_native_state(me->state);
transition(map_external_status(native_state.native_status()));
if (me->state.status() == ORDER_STATUS_WORKING)
{
@@ -1041,11 +1046,22 @@ void ICENativeOrder::setup_ids(const std::string& sender_compid)
me->sender_compid = std::atoi(sender_compid.c_str());
int digs = count_digits(me->sender_compid);
me->id_scale = md::pow10(12-digs);
me->update_scale = 8 * md::pow10(11-digs);
me->cancel_scale = 9 * md::pow10(11-digs);
generate_update_ids();
}
int64_t ICENativeOrder::get_clordid(uint32_t bts_id)
void ICENativeOrder::generate_update_ids()
{
const std::string& scope = std::to_string(me->sender_compid);
auto ids = bts::utils::gen_ids(scope, 50);
for(const auto& i : ids)
me->update_clordid_queue.push(i);
auto cids = bts::utils::gen_ids(scope, 5);
for(const auto& ci : cids)
me->cancel_clordid_queue.push(ci);
}
int64_t ICENativeOrder::get_clordid(uint64_t bts_id)
{
int64_t id = me->id_scale * me->sender_compid + (bts_id % me->id_scale);
return id;
@@ -1060,20 +1076,20 @@ void ICENativeOrder::init_fix()
me->update_encoding = FIXFragment{};
me->cancel_encoding = FIXFragment{};
auto const &def = me->definition;
auto const &sec = *me->sec;
const auto &def = me->definition;
const auto &sec = *me->sec;
bts_assert(sec.has_ice());
auto const &rr = get_native_state(me->state).routing_record();
const auto &rr = get_native_state(me->state).routing_record();
std::string memo(memo_sz(), ' ');
encode_memo(key(), SecurityKey(sec.id()), &memo);
auto combined_clorid = get_clordid(key().value());
me->orig_clordid = get_clordid(key().value());
// initialize create FIX
auto &create_encoding = me->create_encoding;
create_encoding.add<fix::Memo>(memo);
create_encoding.add<fix::Int_ClOrdID>(combined_clorid);
create_encoding.add<fix::Int_ClOrdID>(me->orig_clordid);
create_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));
//create_encoding.add<fix::OnBehalfOfCompID>(""); //optional, unclear if we need
create_encoding.add<fix::SenderSubID>(rr.operator_id());
@@ -1099,7 +1115,8 @@ void ICENativeOrder::init_fix()
// initialize update FIX
auto &update_encoding = me->update_encoding;
update_encoding.add<fix::Int_OrigClOrdID>(combined_clorid);
update_encoding.add<fix::Memo>(memo);
me->update_orig_clordid_bm = update_encoding.add<fix::Int_OrigClOrdID>(me->orig_clordid);
update_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));
//update_encoding.add<fix::OnBehalfOfCompID>(""); //optional, unclear if we need
update_encoding.add<fix::SenderSubID>(rr.operator_id());
@@ -1111,7 +1128,7 @@ void ICENativeOrder::init_fix()
update_encoding.add<fix::Side>(def.side());
me->update_transact_time_bm = update_encoding.add<fix::TransactTimeStr>(datetime::FIX_timestamp(datetime::now()));
me->update_quantity_bm = update_encoding.add<fix::OrderQty>(0, quantity_sz());
me->update_clordid_bm = update_encoding.add<fix::Int_ClOrdID>(combined_clorid, count_digits(combined_clorid));
me->update_clordid_bm = update_encoding.add<fix::Int_ClOrdID>(me->orig_clordid);
update_encoding.add<fix::TimeInForce>(def.time_in_force());
if(rr.account() != "")
update_encoding.add<fix::ClearingAccount>(rr.account());
@@ -1127,12 +1144,13 @@ void ICENativeOrder::init_fix()
// initialize cancel FIX
auto &cancel_encoding = me->cancel_encoding;
cancel_encoding.add<fix::Int_OrigClOrdID>(combined_clorid);
cancel_encoding.add<fix::Memo>(memo);
me->cancel_orig_clordid_bm = cancel_encoding.add<fix::Int_OrigClOrdID>(me->orig_clordid);
cancel_encoding.add<fix::CompanyID>(std::atoi(rr.company_id().c_str()));
cancel_encoding.add<fix::OriginatorUserID>(rr.authorized_trader());
cancel_encoding.add<fix::Int_Symbol>(sec.ice().exchange_id());
cancel_encoding.add<fix::Side>(def.side());
me->cancel_clordid_bm = cancel_encoding.add<fix::Int_ClOrdID>(combined_clorid, count_digits(combined_clorid));
me->cancel_clordid_bm = cancel_encoding.add<fix::Int_ClOrdID>(me->orig_clordid);
// special tags
switch (def.custom_def().custom_case())
@@ -1213,8 +1231,8 @@ void ICENativeOrder::transition(api::orderman::OrderStatus new_status, std::stri
void ICENativeOrder::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);
const auto &from = OrderStatus_Name(me->state.status());
const auto &to = OrderStatus_Name(new_status);
if (from != to)
LOG(OrderMan, level, "Transitioning order {} from {} to {}. Msg: {}", key().value(), from, to, msg);
me->state.set_status(new_status);
@@ -1223,8 +1241,8 @@ void ICENativeOrder::transition(log::Level level, api::orderman::OrderStatus new
void ICENativeOrder::transition(api::orderman::OrderStatus new_status)
{
auto const &from = OrderStatus_Name(me->state.status());
auto const &to = OrderStatus_Name(new_status);
const auto &from = OrderStatus_Name(me->state.status());
const auto &to = OrderStatus_Name(new_status);
if (from != to)
LOG(OrderMan, Info, "Transitioning order {} from {} to {}", key().value(), from, to);
else
+15 -11
View File
@@ -17,24 +17,27 @@ class ICENativeOrder : public NativeOrder {
ICENativeOrder();
~ICENativeOrder() override;
api::orderman::OrderDefinition const &definition() const;
void on_init_new(api::orderman::OrderDefinition const &,
const PreActivationOrderServices &) override;
void on_init_recovered(api::orderman::OrderRecord const &,
const api::orderman::OrderDefinition& definition() const;
void on_init_new(const api::orderman::OrderDefinition&,
const PreActivationOrderServices&) override;
void on_init_recovered(const api::orderman::OrderRecord&,
const PreActivationOrderServices &) override;
OrderOpResult on_activate(Price, Quantity, OrderServices &) override;
OrderOpResult on_update(Price, Quantity) override;
OrderOpResult on_update(api::orderman::Update const &) override;
OrderOpResult on_update(const api::orderman::Update&) override;
OrderOpResult on_detach() override;
OrderOpResult on_cancel() override;
void on_attached(api::orderman::OrderDefinition const &new_parent) override;
void on_attached(const api::orderman::OrderDefinition &new_parent) override;
api::orderman::OrderDefinition
on_init_from_exe_report(ExecutionReport const &, const PreActivationOrderServices &) override;
on_init_from_exe_report(const ExecutionReport &, const PreActivationOrderServices &) override;
protected:
void warm_up_activate(OrderServicesData &, OrderServices &) override;
void init_recovered_common(const api::orderman::OrderRecord &,
const PreActivationOrderServices &);
private:
struct PImpl;
@@ -51,12 +54,12 @@ class ICENativeOrder : public NativeOrder {
void transition(log::Level,
api::orderman::OrderStatus new_state,
std::string const &msg);
const std::string& msg);
void transition(api::orderman::OrderStatus new_state,
std::string const &msg);
const std::string& msg);
void transition(api::orderman::OrderStatus new_state);
void transition_to_error(api::orderman::NativeOrderState::SubError sub_error,
std::string const &msg);
const std::string& msg);
void update_working_position();
bool has_exchange_order_id();
@@ -68,7 +71,8 @@ class ICENativeOrder : public NativeOrder {
get_native_state(api::orderman::OrderState &);
void setup_ids(const std::string& sender_compid);
int64_t get_clordid(uint32_t);
int64_t get_clordid(uint64_t);
void generate_update_ids();
};
} // namespace orderman