Adding results to order operations.

This commit is contained in:
Pedro Pinto committed 2019-01-07 18:06:46 -05:00
1 parent abc2e55610
commit 8be8a67f18
33 files changed
+408 -277

No files matched your search

+2
View File
@@ -430,6 +430,8 @@ enum OrderError
ORDER_ERROR_ORDER_NOT_ACK = 7;
ORDER_ERROR_SERVER_NOT_READY = 8;
ORDER_ERROR_OK = 9;
ORDER_ERROR_OP_NOT_SUPPORTED = 10;
ORDER_ERROR_INVALID_OP = 11;
}
// Trigger Condition /////////////////////////////////
+58 -73
View File
@@ -8,14 +8,15 @@
#include "lib/orderman/events/NewAdminDataEvent.h"
#include "lib/orderman/events/NewSecuritiesEvent.h"
#include "lib/orderman/events/OrderManagerReadyEvent.h"
#include "lib/orderman/events/OrderOpResultEvent.h"
#include "lib/orderman/events/StoredFillEvent.h"
#include "lib/orderman/events/StoredOrderEvent.h"
#include "lib/orderman/events/UpdateOrderEvent.h"
#include "lib/orderman/order_factory/OrderFactory.h"
#include "lib/orderman/order_router/OrderRouter.h"
#include "lib/orderman/securities/MapSecurityDB.h"
#include "lib/utils/PBUtils.h"
#include "lib/tracing/PerfLog.h"
#include "lib/utils/PBUtils.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
@@ -27,18 +28,20 @@ namespace orderman {
struct ServiceBridge::PImpl {
PImpl(OnReady const &on_ready, OnOrders const &on_orders,
OnFills const &on_fills,
OnFills const &on_fills, OnOrderOpResult const &on_order_op_result,
DynamicOrderRegistry const &dyn_order_registry,
mercury::BrokerProxy &service_call_marshaller)
: on_ready(on_ready), on_orders(on_orders), on_fills(on_fills),
have_orders(false), have_securities(false), order_manager_ready(false),
sec_db(), order_router(),
on_order_op_result(on_order_op_result), have_orders(false),
have_securities(false), order_manager_ready(false), sec_db(),
order_router(),
order_factory(sec_db, order_router, dyn_order_registry),
known_orders(), service_call_marshaller(service_call_marshaller) {}
OnReady on_ready;
OnOrders on_orders;
OnFills on_fills;
OnOrderOpResult on_order_op_result;
bool have_orders;
bool have_securities;
bool order_manager_ready;
@@ -58,10 +61,11 @@ struct ServiceBridge::PImpl {
ServiceBridge::ServiceBridge(OnReady const &on_ready, OnOrders const &on_orders,
OnFills const &on_fills,
OnOrderOpResult const &on_order_op_result,
DynamicOrderRegistry const &dyn_order_registry,
mercury::BrokerProxy &service_call_marshaller)
: me(new PImpl(on_ready, on_orders, on_fills, dyn_order_registry,
service_call_marshaller)) {}
: me(new PImpl(on_ready, on_orders, on_fills, on_order_op_result,
dyn_order_registry, service_call_marshaller)) {}
ServiceBridge::~ServiceBridge() {}
@@ -73,6 +77,7 @@ void ServiceBridge::init() {
subscribe<StoredFillEvent>([this](auto const &u) { this->on(u); });
subscribe<StoredOrderEvent>([this](auto const &u) { this->on(u); });
subscribe<OrderManagerReadyEvent>([this](auto const &u) { this->on(u); });
subscribe<OrderOpResultEvent>([this](auto const &u) { this->on(u); });
me->activate_order_pub = make_stream<ActivateOrderEvent>();
me->update_order_pub = make_stream<UpdateOrderEvent>();
@@ -136,105 +141,85 @@ void ServiceBridge::on(mercury::Update<NewAdminDataEvent> const &update) {
me->order_router.update(*ev.admin_data);
}
api::orderman::Response
ServiceBridge::create_order(api::orderman::Create const &c) {
void ServiceBridge::on(mercury::Update<OrderOpResultEvent> const &update) {
if (update.events)
for (auto ev : *(update.events))
me->on_order_op_result(ev);
}
void ServiceBridge::create_order(uint32_t rid, api::orderman::Create const &c) {
LOG(OrderMan, Info, "Received new order from client: {}",
utils::pb::to_string(c));
std::promise<api::orderman::Response> p;
auto f = p.get_future();
me->service_call_marshaller.schedule_action([this, &c, &p]() {
api::orderman::Response r;
me->service_call_marshaller.schedule_action([this, c, rid]() {
if (is_ready()) {
auto &order =
me->order_factory.create(null_order_key(), c.new_order());
me->known_orders.insert(order.key());
publish(me->activate_order_pub, order, Price(c.price()),
publish(me->activate_order_pub, rid, order, Price(c.price()),
Quantity(c.quantity()), trace::CorID());
r.set_order_key(order.key().value());
r.set_error_code(api::orderman::ORDER_ERROR_OK);
} else
r.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
p.set_value(r);
me->on_order_op_result(OrderOpResultEvent(
null_order_key(), rid,
OrderOpResult(api::orderman::ORDER_ERROR_SERVER_NOT_READY)));
});
return f.get();
}
api::orderman::Response
ServiceBridge::update_order(api::orderman::Update const &c) {
void ServiceBridge::update_order(uint32_t rid, api::orderman::Update const &c) {
LOG(OrderMan, Info, "Received order update from client: {}",
utils::pb::to_string(c));
std::promise<api::orderman::Response> p;
auto f = p.get_future();
me->service_call_marshaller.schedule_action([this, &c, &p]() {
api::orderman::Response r;
me->service_call_marshaller.schedule_action([this, c, rid]() {
auto ok = OrderKey(c.order_key());
if (is_ready()) {
auto ok = OrderKey(c.order_key());
r.set_order_key(c.order_key());
if (me->known_orders.count(ok)) {
publish(me->update_order_pub,c);
r.set_error_code(api::orderman::ORDER_ERROR_OK);
} else
r.set_error_code(api::orderman::ORDER_ERROR_UNKNOWN_ORDER);
if (me->known_orders.count(ok))
publish(me->update_order_pub, rid, c);
else
me->on_order_op_result(OrderOpResultEvent(
ok, rid,
OrderOpResult(api::orderman::ORDER_ERROR_UNKNOWN_ORDER)));
} else
r.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
p.set_value(r);
me->on_order_op_result(OrderOpResultEvent(
ok, rid,
OrderOpResult(api::orderman::ORDER_ERROR_SERVER_NOT_READY)));
});
return f.get();
}
api::orderman::Response
ServiceBridge::cancel_order(api::orderman::Cancel const &c) {
void ServiceBridge::cancel_order(uint32_t rid, api::orderman::Cancel const &c) {
LOG(OrderMan, Info, "Received order cancel from client: {}",
utils::pb::to_string(c));
std::promise<api::orderman::Response> p;
auto f = p.get_future();
me->service_call_marshaller.schedule_action([this, &c, &p]() {
api::orderman::Response r;
me->service_call_marshaller.schedule_action([this, c, rid]() {
auto ok = OrderKey(c.order_key());
if (is_ready()) {
auto ok = OrderKey(c.order_key());
r.set_order_key(c.order_key());
if (me->known_orders.count(ok)) {
publish(me->cancel_order_pub, ok);
r.set_error_code(api::orderman::ORDER_ERROR_OK);
} else
r.set_error_code(api::orderman::ORDER_ERROR_UNKNOWN_ORDER);
if (me->known_orders.count(ok))
publish(me->cancel_order_pub, rid, ok);
else
me->on_order_op_result(OrderOpResultEvent(
ok, rid,
OrderOpResult(api::orderman::ORDER_ERROR_UNKNOWN_ORDER)));
} else
r.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
p.set_value(r);
me->on_order_op_result(OrderOpResultEvent(
ok, rid,
OrderOpResult(api::orderman::ORDER_ERROR_SERVER_NOT_READY)));
});
return f.get();
}
api::orderman::Response
ServiceBridge::crack_order(api::orderman::Crack const &c) {
std::promise<api::orderman::Response> p;
auto f = p.get_future();
me->service_call_marshaller.schedule_action([this, &c, &p]() {
api::orderman::Response r;
void ServiceBridge::crack_order(uint32_t rid, api::orderman::Crack const &c) {
me->service_call_marshaller.schedule_action([this, c, rid]() {
auto ok = OrderKey(c.order_key());
if (is_ready()) {
auto ok = OrderKey(c.order_key());
r.set_order_key(c.order_key());
if (me->known_orders.count(ok)) {
publish(me->crack_order_pub, ok);
r.set_error_code(api::orderman::ORDER_ERROR_OK);
} else
r.set_error_code(api::orderman::ORDER_ERROR_UNKNOWN_ORDER);
if (me->known_orders.count(ok))
publish(me->crack_order_pub, rid, ok);
else
me->on_order_op_result(OrderOpResultEvent(ok,
rid, OrderOpResult(api::orderman::ORDER_ERROR_UNKNOWN_ORDER)));
} else
r.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
p.set_value(r);
me->on_order_op_result(OrderOpResultEvent(ok,
rid, OrderOpResult(api::orderman::ORDER_ERROR_SERVER_NOT_READY)));
});
return f.get();
}
void ServiceBridge::update_admin_data(
+11 -5
View File
@@ -28,6 +28,7 @@ class StoredOrderEvent;
class NewSecuritiesEvent;
class OrderManagerReadyEvent;
class NewAdminDataEvent;
class OrderOpResultEvent;
class DynamicOrderRegistry;
} // namespace orderman
} // namespace bts
@@ -48,9 +49,12 @@ class ServiceBridge : public mercury::Actor {
using OnFills =
std::function<void(std::vector<api::orderman::Fill> const &)>;
using OnOrderOpResult =
std::function<void(OrderOpResultEvent const&)>;
ServiceBridge(OnReady const &, OnOrders const &, OnFills const &,
OnOrderOpResult const&,
DynamicOrderRegistry const &,
mercury::BrokerProxy &service_call_marshaller);
void init() override;
~ServiceBridge();
@@ -59,10 +63,11 @@ class ServiceBridge : public mercury::Actor {
void block_until_ready();
// these can be called from any thread, after block_until_ready() returns
api::orderman::Response create_order(api::orderman::Create const &c);
api::orderman::Response update_order(api::orderman::Update const &c);
api::orderman::Response cancel_order(api::orderman::Cancel const &c);
api::orderman::Response crack_order(api::orderman::Crack const &c);
void create_order(uint32_t rid, api::orderman::Create const &c);
void update_order(uint32_t rid, api::orderman::Update const &c);
void cancel_order(uint32_t rid, api::orderman::Cancel const &c);
void crack_order(uint32_t rid, api::orderman::Crack const &c);
void
update_admin_data(std::shared_ptr<api::admin::AdminData const> const &admin);
@@ -77,6 +82,7 @@ class ServiceBridge : public mercury::Actor {
void on(mercury::Update<NewSecuritiesEvent> const &);
void on(mercury::Update<OrderManagerReadyEvent> const &);
void on(mercury::Update<NewAdminDataEvent> const &);
void on(mercury::Update<OrderOpResultEvent> const &);
};
} // namespace orderman
@@ -47,19 +47,21 @@ class ChildOrder {
&_parent_order_services->activate_child(*_order, p, q, trace);
_active = true;
}
void update(Price p, Quantity q, trace::CorID const &trace = trace::CorID()) {
bts_assert(_order);
bts_assert(_active);
_child_order_services->update(p, q, trace);
}
void update(api::orderman::Update const&update, trace::CorID const& trace = trace::CorID()) {
bts_assert(_order);
bts_assert(_active);
_child_order_services->update(update,trace);
}
void crack(trace::CorID const &trace = trace::CorID()) {
bts_assert(_order);
bts_assert(_active);
_child_order_services->crack(trace);
}
void cancel(trace::CorID const &trace = trace::CorID()) {
bts_assert(_order);
bts_assert(_active);
@@ -149,7 +149,7 @@ void OrderManager::on_order_recovery(
auto &order =
me->services_data.order_factory.recover(ev.order_record);
auto const &def = order.def();
publish_order_def_update(OrderKey(ev.key()),def);
publish_order_def_update(OrderKey(ev.key()), def);
order.init_order_services(me->services_data);
auto r = me->orders.emplace(order.key(), &order);
@@ -188,7 +188,7 @@ void OrderManager::on_execution_report(
&me->services_data.order_factory.recreate_from_exe_report(
*report.data);
auto const &def = order->def();
publish_order_def_update(OrderKey(k),def);
publish_order_def_update(OrderKey(k), def);
order->init_order_services(me->services_data);
auto r = me->orders.emplace(order->key(), order);
bts_assert(r.second);
@@ -204,11 +204,12 @@ void OrderManager::on_activate_order(
for (auto const &ev : *m.events) {
auto order = ev.order;
auto const &def = order->def();
publish_order_def_update(order->key(),def);
publish_order_def_update(order->key(), def);
order->init_order_services(me->services_data);
auto r = me->orders.emplace(order->key(), order);
bts_assert(r.second);
order->on_activate(ev.price, ev.quantity, *order->_services, ev.trace);
auto op_r = order->on_activate(ev.price, ev.quantity, *order->_services, ev.trace);
publish(me->services_data.report_order_op_result_pub,order->key(),ev.req_id,op_r);
}
}
@@ -217,18 +218,21 @@ void OrderManager::on_update_order(const mercury::Update<UpdateOrderEvent> &m) {
for (auto const &ev : *m.events) {
auto k = ev.key();
auto it = me->orders.find(k);
OrderOpResult op_r;
if (it != me->orders.end()) {
if (ev.is_full_update())
it->second->on_update(ev.full_update(), trace::CorID{});
op_r = it->second->on_update(ev.full_update(), trace::CorID{});
else
it->second->on_update(Price(ev.price()), Quantity(ev.quantity()),
op_r = it->second->on_update(Price(ev.price()), Quantity(ev.quantity()),
trace::CorID{});
} else {
op_r = OrderOpResult{api::orderman::ORDER_ERROR_UNKNOWN_ORDER,"Unknown order"};
LOG(OrderMan, Error,
"Received an update request for an unknown order {}. "
"This should not happen and likely indicates a serious bug. ",
ev.key().value());
}
publish(me->services_data.report_order_op_result_pub,k,ev.req_id(),op_r);
}
}
@@ -237,14 +241,17 @@ void OrderManager::on_cancel_order(const mercury::Update<CancelOrderEvent> &m) {
for (auto const &ev : *m.events) {
auto k = ev.key();
auto it = me->orders.find(k);
OrderOpResult op_r;
if (it != me->orders.end())
it->second->on_cancel(ev.trace);
op_r = it->second->on_cancel(ev.trace);
else {
op_r = OrderOpResult{api::orderman::ORDER_ERROR_UNKNOWN_ORDER,"Unknown order"};
LOG(OrderMan, Error,
"Received a cancel request for an unknown order {}. "
"This should not happen and likely indicates a serious bug. ",
ev.key().value());
}
publish(me->services_data.report_order_op_result_pub,k,ev.req_id,op_r);
}
}
@@ -253,14 +260,17 @@ void OrderManager::on_crack_order(const mercury::Update<CrackOrderEvent> &m) {
for (auto const &ev : *m.events) {
auto k = ev.key();
auto it = me->orders.find(k);
OrderOpResult op_r;
if (it != me->orders.end())
it->second->on_crack(ev.trace);
it->second->on_crack(trace::CorID{});
else {
op_r = OrderOpResult{api::orderman::ORDER_ERROR_UNKNOWN_ORDER,"Unknown order"};
LOG(OrderMan, Error,
"Received a crack request for an unknown order {}. "
"This should not happen and likely indicates a serious bug. ",
ev.key().value());
}
publish(me->services_data.report_order_op_result_pub,k,ev.req_id,op_r);
}
}
@@ -277,7 +287,7 @@ OrderServices &OrderManager::activate_child(OrderServices &parent, Order &order,
Price p, Quantity q,
trace::CorID const &trace) {
auto const &def = order.def();
publish_order_def_update(order.key(),def);
publish_order_def_update(order.key(), def);
order.init_order_services(me->services_data, parent);
auto r = me->orders.emplace(order.key(), &order);
@@ -418,6 +428,8 @@ void OrderManager::init_order_services() {
me->services_data.report_order_definition_pub =
make_stream<OrderDefinitionUpdateEvent>();
me->pub_ready = make_stream<OrderManagerReadyEvent>();
me->services_data.report_order_op_result_pub =
make_stream<OrderOpResultEvent>();
// md subs are peculiar in that we try to make them on demand, so
// we publish an event announcing the subscription
@@ -472,7 +484,7 @@ void OrderManager::on_poll() {
void OrderManager::publish_order_def_update(
OrderKey k,
std::shared_ptr<api::orderman::OrderDefinition const> const &def) {
publish(me->services_data.report_order_definition_pub,k,def);
publish(me->services_data.report_order_definition_pub, k, def);
}
} // namespace orderman
@@ -147,27 +147,29 @@ class OrderServices {
ss.queue_fix(mt, f, trace);
}
void log(trace::CorID cid, const char *entry_kind,
uint64_t uint64_1 = 0,const char *txt_1 = "",uint32_t uint32_1 = 0) {
void log(trace::CorID cid, const char *entry_kind, uint64_t uint64_1 = 0,
const char *txt_1 = "", uint32_t uint32_1 = 0) {
_data->log.log(cid, entry_kind, uint64_1, txt_1, uint32_1);
}
trace::ScopedPerfLogEntry log_scope(trace::CorID cid, const char *entry_kind,
uint64_t uint64_1 = 0,const char *txt_1 = "",uint32_t uint32_1 = 0)
{
return trace::ScopedPerfLogEntry(_data->log,cid,entry_kind,uint64_1,txt_1,uint32_1);
uint64_t uint64_1 = 0,
const char *txt_1 = "",
uint32_t uint32_1 = 0) {
return trace::ScopedPerfLogEntry(_data->log, cid, entry_kind, uint64_1,
txt_1, uint32_1);
}
void report_definition(const api::orderman::OrderDefinition &def) {
_owner->set_def(def);
_data->owner.publish(_data->report_order_definition_pub, _owner->key(),_owner->def());
_data->owner.publish(_data->report_order_definition_pub, _owner->key(),
_owner->def());
}
void report_state(const api::orderman::OrderState &state,
trace::CorID const &trace = trace::CorID()) {
OrderStateUpdateEvent ev(_owner->key(), _owner->parent_key(),
state, trace);
OrderStateUpdateEvent ev(_owner->key(), _owner->parent_key(), state,
trace);
_data->owner.publish(_data->report_order_state_pub, ev);
if (orderman::in_terminal_state(state.status())) {
@@ -201,11 +203,7 @@ class OrderServices {
using BookSubID = EventStream<BookUpdateEvent>::SubID;
template <class CB> BookSubID subscribe_to_book(SecurityKey k, CB &&cb) {
return _book_updates.sub(
k, [this, cb](auto const &ev) {
this->on_external_event(ev, cb);
});
k, [this, cb](auto const &ev) { this->on_external_event(ev, cb); });
}
void unsubscribe_from_book(BookSubID sid) { _book_updates.unsub(sid); }
@@ -337,6 +335,11 @@ class OrderServices {
self._owner->on_update(p, q, trace);
});
}
void update(api::orderman::Update const &update, trace::CorID const &trace) {
on_inter_order_call([update, trace](OrderServices &self) {
self._owner->on_update(update, trace);
});
}
void crack(trace::CorID const &trace) {
on_inter_order_call(
[trace](OrderServices &self) { self._owner->on_crack(trace); });
@@ -22,6 +22,8 @@
#include "lib/orderman/events/MDRequestEvent.h"
#include "lib/orderman/events/NewExecutionReportEvent.h"
#include "lib/orderman/events/NewSecuritiesEvent.h"
#include "lib/orderman/events/OrderDefinitionUpdateEvent.h"
#include "lib/orderman/events/OrderOpResultEvent.h"
#include "lib/orderman/events/OrderStateUpdateEvent.h"
#include "lib/orderman/events/SettlementRequestEvent.h"
#include "lib/orderman/events/SettlementUpdateEvent.h"
@@ -30,7 +32,6 @@
#include "lib/orderman/limiter/Limiter.h"
#include "lib/orderman/order_router/OrderRouter.h"
#include "lib/utils/datetime.h"
#include "lib/orderman/events/OrderDefinitionUpdateEvent.h"
#include <boost/date_time/posix_time/posix_time.hpp>
@@ -45,7 +46,8 @@ struct ParentKey {
};
struct SessionServicesData {
SessionServicesData(config::JetFIX::Connection const &cfg, trace::PerfLog &log)
SessionServicesData(config::JetFIX::Connection const &cfg,
trace::PerfLog &log)
: session(cfg.name()), gw_connected(false), cfg(cfg),
governor(cfg.max_order_msgs_per_window(), cfg.window_duration_msecs()),
gw(cfg, log) {}
@@ -73,7 +75,6 @@ struct SessionServicesData {
class OrderServicesData {
public:
OrderServicesData(OrderManager &owner, DynamicOrderRegistry const &b,
trace::PerfLog &l);
@@ -98,7 +99,7 @@ class OrderServicesData {
mercury::Stream<SettlementRequestEvent> settlement_request_pub;
mercury::Stream<OrderStateUpdateEvent> report_order_state_pub;
mercury::Stream<OrderDefinitionUpdateEvent> report_order_definition_pub;
mercury::Stream<OrderOpResultEvent> report_order_op_result_pub;
mercury::TimerEvent last_timer_ev;
std::vector<std::unique_ptr<SessionServicesData>> sessions;
+13 -14
View File
@@ -2,32 +2,31 @@
#include <memory>
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/mercury/events/Event.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/tracing/PerfLog.h"
namespace bts {
namespace orderman {
class Order;
class ActivateOrderEvent : public mercury::Event<ActivateOrderEvent>
{
public:
class ActivateOrderEvent : public mercury::Event<ActivateOrderEvent> {
public:
using SynopsisPolicy = mercury::NoSynopsis;
ActivateOrderEvent (Order &o,Price p, Quantity q) :
order (&o),price(p),quantity(q), trace()
{}
ActivateOrderEvent (Order &o,Price p, Quantity q,trace::CorID trace) :
order (&o),price(p),quantity(q), trace(trace)
{}
ActivateOrderEvent(uint32_t req_id, Order &o, Price p, Quantity q)
: req_id(req_id),order(&o), price(p), quantity(q), trace() {}
Order* order;
ActivateOrderEvent(uint32_t req_id, Order &o, Price p, Quantity q,
trace::CorID trace)
: req_id(req_id), order(&o), price(p), quantity(q), trace(trace) {}
uint32_t req_id;
Order *order;
Price price;
Quantity quantity;
trace::CorID trace;
};
}}
} // namespace orderman
} // namespace bts
+13 -11
View File
@@ -2,26 +2,28 @@
#include <memory>
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/mercury/events/Event.h"
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/tracing/PerfLog.h"
namespace bts {
namespace orderman {
class CancelOrderEvent : public mercury::Event<CancelOrderEvent>
{
public:
class CancelOrderEvent : public mercury::Event<CancelOrderEvent> {
public:
using SynopsisPolicy = mercury::NoSynopsis;
CancelOrderEvent (OrderKey k) : k (k), trace() {}
CancelOrderEvent (OrderKey k,trace::CorID const&trace) : k (k), trace(trace) {}
// used by ContentSubscription
OrderKey key() const {return k;}
CancelOrderEvent(uint32_t req_id, OrderKey k)
: req_id(req_id), k(k), trace() {}
CancelOrderEvent(uint32_t req_id, OrderKey k, trace::CorID const &trace)
: req_id(req_id), k(k), trace(trace) {}
uint32_t req_id;
// used by ContentSubscription
OrderKey key() const { return k; }
OrderKey k;
trace::CorID trace;
};
}}
} // namespace orderman
} // namespace bts
+5 -8
View File
@@ -13,16 +13,13 @@ class CrackOrderEvent : public mercury::Event<CrackOrderEvent> {
public:
using SynopsisPolicy = mercury::NoSynopsis;
CrackOrderEvent(OrderKey k)
: k(k), trace() {}
CrackOrderEvent(OrderKey k, trace::CorID const &trace)
: k(k), trace(trace) {}
CrackOrderEvent(uint32_t req_id, OrderKey k)
: req_id(req_id), k(k) {}
uint32_t req_id;
// used by ContentSubscription
OrderKey key() const { return k; }
OrderKey k;
trace::CorID trace;
};
}
}
} // namespace orderman
} // namespace bts
@@ -0,0 +1,30 @@
#pragma once
#include <memory>
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/mercury/events/Event.h"
#include "lib/orderman/orders/Order.h"
namespace bts {
namespace orderman {
class Order;
class OrderOpResultEvent : public mercury::Event<OrderOpResultEvent>
{
public:
using SynopsisPolicy = mercury::NoSynopsis;
OrderOpResultEvent (OrderKey k, uint32_t req_id,OrderOpResult const &r ) :
ok(k),
req_id(req_id),
result (r)
{}
OrderKey ok;
uint32_t req_id;
OrderOpResult result;
};
}}
+4 -3
View File
@@ -14,8 +14,8 @@ class UpdateOrderEvent : public mercury::Event<UpdateOrderEvent>
public:
using SynopsisPolicy = mercury::NoSynopsis;
UpdateOrderEvent (api::orderman::Update const&update) :
_update(update)
UpdateOrderEvent (uint32_t rid,api::orderman::Update const&update) :
_req_id(rid), _update(update)
{}
// used by ContentSubscription
@@ -24,8 +24,9 @@ public:
Quantity quantity() const {return Quantity(_update.quantity());}
bool is_full_update() const {return _update.has_custom();}
api::orderman::Update const &full_update() const {return _update;}
uint32_t req_id() const {return _req_id;}
private:
uint32_t _req_id;
api::orderman::Update _update;
};
+4 -4
View File
@@ -44,14 +44,14 @@ void DynamicOrder::on_init_recovered(api::orderman::OrderRecord const &rec,
me->state.set_last_msg(msg);
}
void DynamicOrder::on_activate(Price, Quantity, OrderServices &services,
OrderOpResult DynamicOrder::on_activate(Price, Quantity, OrderServices &services,
trace::CorID const &) {
services.report_state(me->state);
return OrderOpResult{};
}
void DynamicOrder::on_update(Price, Quantity, trace::CorID const &) {}
void DynamicOrder::on_crack(trace::CorID const &) {}
void DynamicOrder::on_cancel(trace::CorID const &) {}
OrderOpResult DynamicOrder::on_update(Price, Quantity, trace::CorID const &) {return OrderOpResult{};}
OrderOpResult DynamicOrder::on_cancel(trace::CorID const &) {return OrderOpResult{};}
} // namespace orderman
} // namespace bts
+3 -4
View File
@@ -18,10 +18,9 @@ public:
const PreActivationOrderServices&) override;
void on_init_recovered(api::orderman::OrderRecord const&,
const PreActivationOrderServices &) override;
void on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
void on_update(Price , Quantity,trace::CorID const&) override ;
void on_crack(trace::CorID const&) override ;
void on_cancel(trace::CorID const&) override ;
OrderOpResult on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
OrderOpResult on_update(Price , Quantity,trace::CorID const&) override ;
OrderOpResult on_cancel(trace::CorID const&) override ;
private:
struct PImpl;
+20 -6
View File
@@ -103,8 +103,9 @@ void IcebergOrder::on_init_recovered(api::orderman::OrderRecord const &rec,
}
}
void IcebergOrder::on_activate(Price p, Quantity q, OrderServices &services,
trace::CorID const &) {
OrderOpResult IcebergOrder::on_activate(Price p, Quantity q,
OrderServices &services,
trace::CorID const &) {
bts_assert(!me->services);
me->services = &services;
me->child_builder.activate(services);
@@ -143,9 +144,11 @@ void IcebergOrder::on_activate(Price p, Quantity q, OrderServices &services,
break;
}
report_state();
return OrderOpResult{};
}
void IcebergOrder::on_update(Price p, Quantity q, trace::CorID const &) {
OrderOpResult IcebergOrder::on_update(Price p, Quantity q,
trace::CorID const &) {
switch (me->state.status()) {
case ORDER_STATUS_WORKING:
case ORDER_STATUS_PENDING_WORKING:
@@ -169,11 +172,20 @@ void IcebergOrder::on_update(Price p, Quantity q, trace::CorID const &) {
break;
}
report_state();
return OrderOpResult{};
}
void IcebergOrder::on_crack(trace::CorID const &) {}
OrderOpResult IcebergOrder::on_update(api::orderman::Update const &,
trace::CorID const &) {
void IcebergOrder::on_cancel(trace::CorID const &) {
return OrderOpResult{};
}
OrderOpResult IcebergOrder::on_crack(trace::CorID const &) {
return OrderOpResult{};
}
OrderOpResult IcebergOrder::on_cancel(trace::CorID const &) {
switch (me->state.status()) {
case ORDER_STATUS_WORKING:
LOG(OrderMan, Info, "Canceling Iceberg Order {}", key().value());
@@ -196,6 +208,7 @@ void IcebergOrder::on_cancel(trace::CorID const &) {
break;
}
report_state();
return OrderOpResult{};
}
void IcebergOrder::transition(api::orderman::OrderStatus new_status,
@@ -255,7 +268,8 @@ void IcebergOrder::send_next_child_order() {
key().value(), me->child.order.key().value(), to_send, me->state.price(),
me->state.filled_quantity(), me->state.quantity());
me->child.order.activate(Price(me->state.price()), Quantity(to_send), trace::CorID());
me->child.order.activate(Price(me->state.price()), Quantity(to_send),
trace::CorID());
}
void IcebergOrder::on_child_order_update(OrderStateUpdateEvent const &ev) {
+5 -4
View File
@@ -20,10 +20,11 @@ public:
const PreActivationOrderServices&) override;
void on_init_recovered(api::orderman::OrderRecord const&,
const PreActivationOrderServices &) override;
void on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
void on_update(Price , Quantity,trace::CorID const&) override ;
void on_crack(trace::CorID const&) override ;
void on_cancel(trace::CorID const&) override ;
OrderOpResult on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
OrderOpResult on_update(Price , Quantity,trace::CorID const&) override ;
OrderOpResult on_update(api::orderman::Update const&update, trace::CorID const&trace) override;
OrderOpResult on_crack(trace::CorID const&) override ;
OrderOpResult on_cancel(trace::CorID const&) override ;
private:
void report_state();
+16 -9
View File
@@ -178,7 +178,7 @@ void NativeOrder::on_init_recovered(OrderRecord const &rec,
}
}
api::orderman::OrderDefinition const&
api::orderman::OrderDefinition const &
NativeOrder::on_init_from_exe_report(ExecutionReport const &er,
const PreActivationOrderServices &os) {
auto k = er.order_key;
@@ -274,9 +274,10 @@ NativeOrder::on_init_from_exe_report(ExecutionReport const &er,
NativeOrder::~NativeOrder() {}
void NativeOrder::on_activate(Price p, Quantity q,
bts::orderman::OrderServices &services,
trace::CorID const &trace) {
OrderOpResult
NativeOrder::on_activate(Price p, Quantity q,
bts::orderman::OrderServices &services,
trace::CorID const &trace) {
auto scoped_log =
services.log_scope(trace, "NativeOrder::on_activate", key().value());
@@ -401,7 +402,7 @@ void NativeOrder::on_activate(Price p, Quantity q,
LOG(OrderMan, Info, "Sent new order with key {} to gateway",
key().value());
// early return so we skip the expensive report_state() call
return;
return OrderOpResult{};
}
// all cases below are for orders recovered from disk
@@ -465,9 +466,11 @@ void NativeOrder::on_activate(Price p, Quantity q,
break;
}
report_state();
return OrderOpResult{};
}
void NativeOrder::on_update(Price p, Quantity q, trace::CorID const &trace) {
OrderOpResult NativeOrder::on_update(Price p, Quantity q,
trace::CorID const &trace) {
auto scoped_log =
me->services->log_scope(trace, "NativeOrder::on_update", key().value());
@@ -544,7 +547,7 @@ void NativeOrder::on_update(Price p, Quantity q, trace::CorID const &trace) {
me->state.set_last_msg("");
// early return so we skip report_state (for speed)
return;
return OrderOpResult{};
}
case ORDER_STATUS_DISCONNECTED:
@@ -563,11 +566,14 @@ void NativeOrder::on_update(Price p, Quantity q, trace::CorID const &trace) {
break;
}
report_state();
return OrderOpResult{};
}
void NativeOrder::on_crack(trace::CorID const &) {}
OrderOpResult NativeOrder::on_crack(trace::CorID const &) {
return OrderOpResult{};
}
void NativeOrder::on_cancel(trace::CorID const &trace) {
OrderOpResult NativeOrder::on_cancel(trace::CorID const &trace) {
auto scoped_log =
me->services->log_scope(trace, "NativeOrder::on_cancel", key().value());
switch (me->state.status()) {
@@ -601,6 +607,7 @@ void NativeOrder::on_cancel(trace::CorID const &trace) {
break;
}
report_state();
return OrderOpResult{};
}
bool NativeOrder::is_old_exe_report(
+6 -5
View File
@@ -23,11 +23,12 @@ class NativeOrder : public Order {
const PreActivationOrderServices &) override;
void on_init_recovered(api::orderman::OrderRecord const &,
const PreActivationOrderServices &) override;
void on_activate(Price, Quantity, OrderServices &,
trace::CorID const &) override;
void on_update(Price, Quantity, trace::CorID const &) override;
void on_crack(trace::CorID const &) override;
void on_cancel(trace::CorID const &) override;
OrderOpResult on_activate(Price, Quantity, OrderServices &,
trace::CorID const &) override;
OrderOpResult on_update(Price, Quantity, trace::CorID const &) override;
OrderOpResult on_crack(trace::CorID const &) override;
OrderOpResult on_cancel(trace::CorID const &) override;
api::orderman::OrderDefinition const &
on_init_from_exe_report(ExecutionReport const &,
+21 -15
View File
@@ -4,32 +4,38 @@
namespace bts {
namespace orderman {
Order::Order()
{
_services = std::make_unique<OrderServices>(*this);
}
Order::Order() { _services = std::make_unique<OrderServices>(*this); }
void Order::init_order_services(OrderServicesData &osd)
{
void Order::init_order_services(OrderServicesData &osd) {
_services->init(osd);
}
void Order::init_order_services(OrderServicesData &osd,OrderServices &parent)
{
_services->init(osd,parent);
void Order::init_order_services(OrderServicesData &osd, OrderServices &parent) {
_services->init(osd, parent);
}
Order::~Order() {}
void Order::on_update(api::orderman::Update const&, trace::CorID const&) {}
OrderOpResult Order::on_update(api::orderman::Update const &,
trace::CorID const &) {
return OrderOpResult{api::orderman::ORDER_ERROR_OP_NOT_SUPPORTED,
"The update operation is not supported by this order type"
void Order::set_def(api::orderman::OrderDefinition const&def)
{
_def = std::make_shared<api::orderman::OrderDefinition const> (def);
};
}
std::shared_ptr<const api::orderman::OrderDefinition> const &Order::def()
{
OrderOpResult Order::on_crack(trace::CorID const&) {
return OrderOpResult{api::orderman::ORDER_ERROR_OP_NOT_SUPPORTED,
"The crack operation is not supported by this order type"
};
}
void Order::set_def(api::orderman::OrderDefinition const &def) {
_def = std::make_shared<api::orderman::OrderDefinition const>(def);
}
std::shared_ptr<const api::orderman::OrderDefinition> const &Order::def() {
return _def;
}
+7 -5
View File
@@ -1,6 +1,8 @@
#pragma once
#include "lib/orderman/orderman_utils/orderman_common.h"
#include "lib/orderman/orders/OrderOpResult.h"
#include <memory>
// fwd
@@ -44,13 +46,13 @@ class Order {
const PreActivationOrderServices &) = 0;
// activation - cannot be slow
virtual void on_activate(Price, Quantity, OrderServices &, trace::CorID const&) = 0;
virtual OrderOpResult on_activate(Price, Quantity, OrderServices &, trace::CorID const&) = 0;
// order is running, maintenance
virtual void on_update(Price, Quantity, trace::CorID const&) = 0;
virtual void on_update(api::orderman::Update const&, trace::CorID const&) ;
virtual void on_crack(trace::CorID const&) = 0;
virtual void on_cancel(trace::CorID const&) = 0;
virtual OrderOpResult on_update(Price, Quantity, trace::CorID const&) = 0;
virtual OrderOpResult on_update(api::orderman::Update const&, trace::CorID const&) ;
virtual OrderOpResult on_crack(trace::CorID const&);
virtual OrderOpResult on_cancel(trace::CorID const&) = 0;
private:
OrderKey _key;
+22
View File
@@ -0,0 +1,22 @@
#pragma once
#include "lib/api/services/OrderService.pb.h"
#include <string>
namespace bts {
namespace orderman {
struct OrderOpResult {
OrderOpResult() : error(api::orderman::ORDER_ERROR_OK), error_msg() {}
OrderOpResult(api::orderman::OrderError e, std::string const &error_msg)
: error(e), error_msg(error_msg) {}
OrderOpResult(api::orderman::OrderError e) : error(e), error_msg() {}
api::orderman::OrderError error;
std::string error_msg;
};
} // namespace orderman
} // namespace bts
+12 -5
View File
@@ -84,8 +84,9 @@ void TimeBoxOrder::on_init_recovered(api::orderman::OrderRecord const &rec,
}
}
void TimeBoxOrder::on_activate(Price p, Quantity q, OrderServices &services,
trace::CorID const &) {
OrderOpResult TimeBoxOrder::on_activate(Price p, Quantity q,
OrderServices &services,
trace::CorID const &) {
bts_assert(!me->services);
me->services = &services;
me->child_builder.activate(services);
@@ -121,9 +122,11 @@ void TimeBoxOrder::on_activate(Price p, Quantity q, OrderServices &services,
break;
}
report_state();
return OrderOpResult{};
}
void TimeBoxOrder::on_update(Price p, Quantity q, trace::CorID const &) {
OrderOpResult TimeBoxOrder::on_update(Price p, Quantity q,
trace::CorID const &) {
LOG(OrderMan, Info, "Updating TimeBox Order {}", key().value());
switch (me->state.status()) {
@@ -181,11 +184,14 @@ void TimeBoxOrder::on_update(Price p, Quantity q, trace::CorID const &) {
break;
}
report_state();
return OrderOpResult{};
}
void TimeBoxOrder::on_crack(trace::CorID const &) {}
OrderOpResult TimeBoxOrder::on_crack(trace::CorID const &) {
return OrderOpResult{};
}
void TimeBoxOrder::on_cancel(trace::CorID const &) {
OrderOpResult TimeBoxOrder::on_cancel(trace::CorID const &) {
LOG(OrderMan, Info, "Canceling TimeBox Order {}", key().value());
switch (me->state.status()) {
@@ -240,6 +246,7 @@ void TimeBoxOrder::on_cancel(trace::CorID const &) {
break;
}
report_state();
return OrderOpResult{};
}
void TimeBoxOrder::transition(api::orderman::OrderStatus new_status,
+4 -4
View File
@@ -19,10 +19,10 @@ public:
const PreActivationOrderServices&) override;
void on_init_recovered(api::orderman::OrderRecord const&,
const PreActivationOrderServices &) override;
void on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
void on_update(Price , Quantity,trace::CorID const&) override ;
void on_crack(trace::CorID const&) override ;
void on_cancel(trace::CorID const&) override ;
OrderOpResult on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
OrderOpResult on_update(Price , Quantity,trace::CorID const&) override ;
OrderOpResult on_crack(trace::CorID const&) override ;
OrderOpResult on_cancel(trace::CorID const&) override ;
private:
void report_state();
+10 -9
View File
@@ -100,7 +100,7 @@ void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord &rec,
break;
}
}
void TriggerOrder::on_activate(Price price, Quantity qty,
OrderOpResult TriggerOrder::on_activate(Price price, Quantity qty,
OrderServices &services, trace::CorID const &) {
LOG(OrderMan, Info,
"TriggerOrder::on_activate key:{} state:{} price:{} qty:{}", key(),
@@ -116,9 +116,9 @@ void TriggerOrder::on_activate(Price price, Quantity qty,
me->order_builder.activate(services);
me->child_order = me->order_builder.build();
services.subscribe_to_child_updates(
[this](const OrderStateUpdateEvent &os) {
this->_on_child_order_update(os);
});
[this](const OrderStateUpdateEvent &os) {
this->_on_child_order_update(os);
});
services.subscribe_to_book(SecurityKey(me->order_def.security_key()),
[this](const BookUpdateEvent &bk_event) {
this->_on_book_update(bk_event);
@@ -138,9 +138,11 @@ void TriggerOrder::on_activate(Price price, Quantity qty,
break;
}
}
return OrderOpResult{};
}
// order price, qty change
void TriggerOrder::on_update(Price price, Quantity qty, trace::CorID const &) {
OrderOpResult TriggerOrder::on_update(Price price, Quantity qty,
trace::CorID const &) {
LOG(OrderMan, Info,
"TriggerOrder::on_update key:{} state:{} price:{} qty:{}", key(), _state,
price, qty);
@@ -165,11 +167,9 @@ void TriggerOrder::on_update(Price price, Quantity qty, trace::CorID const &) {
case State::END:
break;
}
return OrderOpResult{};
}
void TriggerOrder::on_crack(trace::CorID const &) {
// not supported
}
void TriggerOrder::on_cancel(trace::CorID const &) {
OrderOpResult TriggerOrder::on_cancel(trace::CorID const &) {
LOG(OrderMan, Info, "TriggerOrder::on_cancel key:{} state:{}", key(),
_state);
me->cancel_mode = CancelMode::external;
@@ -193,6 +193,7 @@ void TriggerOrder::on_cancel(trace::CorID const &) {
case State::END:
break;
}
return OrderOpResult{};
}
void TriggerOrder::_on_book_update(const BookUpdateEvent &b_event) {
switch (_state) {
+3 -4
View File
@@ -54,12 +54,11 @@ public:
const PreActivationOrderServices&) override;
void on_init_recovered(api::orderman::OrderRecord const&,
const PreActivationOrderServices &) override;
void on_activate(Price, Quantity,
OrderOpResult on_activate(Price, Quantity,
OrderServices&,
trace::CorID const&) override ;
void on_update(Price, Quantity, trace::CorID const&) override;
void on_crack(trace::CorID const&) override;
void on_cancel(trace::CorID const&) override;
OrderOpResult on_update(Price, Quantity, trace::CorID const&) override;
OrderOpResult on_cancel(trace::CorID const&) override;
private:
// callbacks from book and child order udpates
void _on_book_update(const BookUpdateEvent&);
@@ -139,8 +139,8 @@ void BookAlgo::on_init_recovered(const api::orderman::OrderRecord &rec,
}
}
void BookAlgo::on_activate(Price p, Quantity q, OrderServices &services,
trace::CorID const &) {
OrderOpResult BookAlgo::on_activate(Price p, Quantity q, OrderServices &services,
trace::CorID const &) {
bts_assert(!me->services);
me->services = &services;
switch (this_state().status()) {
@@ -179,9 +179,10 @@ void BookAlgo::on_activate(Price p, Quantity q, OrderServices &services,
break;
}
report_state();
return OrderOpResult{};
}
void BookAlgo::on_update(Price p, Quantity q, trace::CorID const &) {
OrderOpResult BookAlgo::on_update(Price p, Quantity q, trace::CorID const &) {
LOG(OrderMan, Info, "Updating BookAlgo {}", key().value());
switch (this_state().status()) {
case ORDER_STATUS_WORKING:
@@ -233,11 +234,10 @@ void BookAlgo::on_update(Price p, Quantity q, trace::CorID const &) {
break;
}
report_state();
return OrderOpResult{};
}
void BookAlgo::on_crack(trace::CorID const &) {}
void BookAlgo::on_cancel(trace::CorID const &) {
OrderOpResult BookAlgo::on_cancel(trace::CorID const &) {
LOG(OrderMan, Info, "Canceling BookAlgo Order {}", key().value());
switch (this_state().status()) {
@@ -287,6 +287,7 @@ void BookAlgo::on_cancel(trace::CorID const &) {
break;
}
report_state();
return OrderOpResult{};
}
void BookAlgo::transition(api::orderman::OrderStatus new_status,
@@ -24,10 +24,9 @@ public:
const PreActivationOrderServices&) override;
void on_init_recovered(const api::orderman::OrderRecord&,
const PreActivationOrderServices &) override;
void on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
void on_update(Price , Quantity,trace::CorID const&) override ;
void on_crack(trace::CorID const&) override ;
void on_cancel(trace::CorID const&) override ;
OrderOpResult on_activate(Price,Quantity,OrderServices &, trace::CorID const&) override ;
OrderOpResult on_update(Price , Quantity,trace::CorID const&) override ;
OrderOpResult on_cancel(trace::CorID const&) override ;
protected:
virtual void setup_child(const api::orderman::OrderDefinition& parent, const PreActivationOrderServices&,
@@ -54,31 +54,28 @@ void SpreaderOrder::on_init_recovered(const bts::api::orderman::OrderRecord& ord
SpreaderPreActivationOrderServices(&pao_services));
_report_state();
}
void SpreaderOrder::on_activate(Price price, Quantity quantity,
OrderOpResult SpreaderOrder::on_activate(Price price, Quantity quantity,
OrderServices& services, const trace::CorID&){
if (!_active) return;
if (!_active) return OrderOpResult{api::orderman::ORDER_ERROR_INVALID_OP,"Order is not active"};
SpreaderOrderServices spreader_order_services (&services);
_on_activate(price, quantity, spreader_order_services);
_report_state();
return OrderOpResult{};
}
void SpreaderOrder::on_update(Price price, Quantity quantity,trace::CorID const&){
if (!_active) return;
OrderOpResult SpreaderOrder::on_update(Price price, Quantity quantity,trace::CorID const&){
if (!_active) return OrderOpResult{api::orderman::ORDER_ERROR_INVALID_OP,"Order is not active"};
LOG(OrderMan, Info, "SpreaderOrder.on_update key:{} price:{} quantity:{}",
key().value(), price.value(), quantity.value());
_state_worker->on_update(price, quantity);
_report_state();
return OrderOpResult{};
}
void SpreaderOrder::on_cancel(trace::CorID const&){
if (!_active) return;
OrderOpResult SpreaderOrder::on_cancel(trace::CorID const&){
if (!_active) return OrderOpResult{api::orderman::ORDER_ERROR_INVALID_OP,"Order is not active"};
LOG(OrderMan, Info, "SpreaderOrder.on_cancel key:{}", key().value());
_state_worker->on_cancel();
_report_state();
}
void SpreaderOrder::on_crack(trace::CorID const&){
if (!_active) return;
LOG(OrderMan, Info, "SpreaderOrder.on_crack key: {}", key().value());
_state_worker->on_crack();
_report_state();
return OrderOpResult{};
}
// ISpreaderManager ////////////////////
////////////////////////////////////////
@@ -100,15 +100,12 @@ public:
const PreActivationOrderServices&) override;
// this is in the critical path, orders can be submitted now
// (this is only called once and after the on_init_new)
void on_activate(Price, Quantity, OrderServices&,trace::CorID const&) override;
OrderOpResult on_activate(Price, Quantity, OrderServices&,trace::CorID const&) override;
// called when the user (or a higher level order)
// updates the order's price or quantity
void on_update(Price, Quantity,trace::CorID const&) override;
OrderOpResult on_update(Price, Quantity,trace::CorID const&) override;
// called when the user (or higher level order) cancels an order
void on_cancel(trace::CorID const&) override;
// crack means to let the lower level orders lose from the higher
// level order and cancel the higher level order
void on_crack(trace::CorID const&) override;
OrderOpResult on_cancel(trace::CorID const&) override;
// ISpreaderManager ////////////////////
////////////////////////////////////////
public:
+64 -28
View File
@@ -16,6 +16,7 @@
#include "lib/orderman/actors/SecuritySrc.h"
#include "lib/orderman/actors/ServiceBridge.h"
#include "lib/orderman/actors/order_manager/OrderManager.h"
#include "lib/orderman/events/OrderOpResultEvent.h"
#include "lib/orderman/order_factory/DynamicOrderRegistry.h"
#include "lib/plugin/SparkServices.h"
#include "lib/plugin/plugin.h"
@@ -89,11 +90,13 @@ ActorThread *find_thread_for_actor(
struct OrderServiceServer::PImpl {
PImpl(bts::api::ServiceContext &ctx,
std::shared_ptr<api::ISyntheticSecurityService> &ss,
DynamicOrderRegistry const &d, metrics::MetricsContainer &stats, trace::PerfLog &log)
DynamicOrderRegistry const &d, metrics::MetricsContainer &stats,
trace::PerfLog &log)
: service_bridge(), service_ready(false), known_orders(), known_fills(),
publish_orders(), publish_fills(),
admin_service(ctx.locate<api::admin::AdminService>()), md_consumer(ss),
stats(stats), dyn_order_registry(d),log(log) {}
stats(stats), dyn_order_registry(d), log(log), in_flight_order_ops(),
current_req_op_id(0) {}
ServiceBridge *service_bridge;
@@ -110,6 +113,9 @@ struct OrderServiceServer::PImpl {
metrics::MetricsContainer &stats;
DynamicOrderRegistry const &dyn_order_registry;
trace::PerfLog &log;
std::unordered_map<uint32_t, api::Response<api::orderman::Response>>
in_flight_order_ops;
uint32_t current_req_op_id;
};
OrderServiceServer::OrderServiceServer(
@@ -117,7 +123,8 @@ OrderServiceServer::OrderServiceServer(
std::shared_ptr<api::ISyntheticSecurityService> &ss,
DynamicOrderRegistry const &d, metrics::MetricsContainer &stats,
trace::PerfLog &log)
: api::orderman::OrderServiceBase(ctx), me(new PImpl(ctx, ss, d, stats,log)) {
: api::orderman::OrderServiceBase(ctx),
me(new PImpl(ctx, ss, d, stats, log)) {
me->publish_orders = make_orders_publisher();
me->publish_fills = make_fills_publisher();
@@ -137,14 +144,14 @@ OrderServiceServer::OrderServiceServer(
bts_assert_msg(thread,
"Could not find a configured thread for MDSource. See the "
"OrdermanCfg key");
thread->executor.spawn<MDSource>(me->md_consumer, me->stats,log);
thread->executor.spawn<MDSource>(me->md_consumer, me->stats, log);
// OrderManager
thread = find_thread_for_actor("OrderManager", me->actor_threads);
bts_assert_msg(thread,
"Could not find a configured thread for OrderManager. See "
"the OrdermanCfg key");
thread->executor.spawn<OrderManager>(d,me->log);
thread->executor.spawn<OrderManager>(d, me->log);
// Timer
thread = find_thread_for_actor("Timer", me->actor_threads);
@@ -204,6 +211,13 @@ OrderServiceServer::OrderServiceServer(
[this, &ctx](auto const &fill) {
ctx.post([this, fill] { this->on_fills(fill); });
},
[this, &ctx](auto const &order_op_result) {
ctx.post([this, order_op_result] {
this->on_order_op_result(order_op_result);
});
},
me->dyn_order_registry, thread->executor.make_proxy());
thread->executor.activate(me->service_bridge);
@@ -275,51 +289,60 @@ void OrderServiceServer::on_fills(
void OrderServiceServer::create_order(
const api::orderman::Create &c,
const api::Response<api::orderman::Response> &r) {
api::orderman::Response response;
if (!me->service_ready)
if (!me->service_ready) {
api::orderman::Response response;
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
else
response = me->service_bridge->create_order(c);
r(response);
r(response);
} else {
me->in_flight_order_ops[++me->current_req_op_id] = r;
me->service_bridge->create_order(me->current_req_op_id, c);
}
}
void OrderServiceServer::cancel_order(
const api::orderman::Cancel &cancel,
const api::Response<api::orderman::Response> &r) {
api::orderman::Response response;
response.set_order_key(cancel.order_key());
if (!me->service_ready)
if (!me->service_ready) {
api::orderman::Response response;
response.set_order_key(cancel.order_key());
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
else
response = me->service_bridge->cancel_order(cancel);
r(response);
r(response);
} else {
me->in_flight_order_ops[++me->current_req_op_id] = r;
me->service_bridge->cancel_order(me->current_req_op_id, cancel);
}
}
void OrderServiceServer::update_order(
const api::orderman::Update &update,
const api::Response<api::orderman::Response> &r) {
api::orderman::Response response;
response.set_order_key(update.order_key());
if (!me->service_ready)
if (!me->service_ready) {
api::orderman::Response response;
response.set_order_key(update.order_key());
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
else
response = me->service_bridge->update_order(update);
r(response);
r(response);
} else {
me->in_flight_order_ops[++me->current_req_op_id] = r;
me->service_bridge->update_order(me->current_req_op_id, update);
}
}
void OrderServiceServer::crack_order(
const api::orderman::Crack &crack,
const api::Response<api::orderman::Response> &r) {
api::orderman::Response response;
response.set_order_key(crack.order_key());
if (!me->service_ready)
if (!me->service_ready) {
api::orderman::Response response;
response.set_order_key(crack.order_key());
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
else
response = me->service_bridge->crack_order(crack);
r(response);
r(response);
} else {
me->in_flight_order_ops[++me->current_req_op_id] = r;
me->service_bridge->crack_order(me->current_req_op_id, crack);
}
}
void OrderServiceServer::get_registered_dynamic_order_types(
@@ -333,5 +356,18 @@ void OrderServiceServer::get_registered_dynamic_order_types(
r(response);
}
void OrderServiceServer::on_order_op_result(
OrderOpResultEvent const &op_result) {
auto it = me->in_flight_order_ops.find(op_result.req_id);
bts_assert(it!=me->in_flight_order_ops.end());
auto &responder = it->second;
api::orderman::Response r;
r.set_order_key(0);
r.set_error_code(op_result.result.error);
r.set_msg(op_result.result.error_msg);
responder(r);
me->in_flight_order_ops.erase(it);
}
} // namespace orderman
} // namespace bts
@@ -15,6 +15,7 @@ class MetricsContainer;
}
namespace orderman {
class DynamicOrderRegistry;
class OrderOpResultEvent;
class OrderServiceServer : public api::orderman::OrderServiceBase {
public:
@@ -43,6 +44,7 @@ class OrderServiceServer : public api::orderman::OrderServiceBase {
std::unique_ptr<PImpl> me;
void on_orders(std::vector<api::orderman::OrderRecord> const &);
void on_fills(std::vector<api::orderman::Fill> const &);
void on_order_op_result(OrderOpResultEvent const&);
};
} // namespace orderman
+1 -1
View File
@@ -18,7 +18,7 @@ class DynamicIcebergOrder : public DynamicOrder {
public:
DynamicIcebergOrder();
~DynamicIcebergOrder();
OrderDefinition const &definition() const override;
OrderDefinition const &definition() const;
void on_init_new(OrderDefinition const &,
const PreActivationOrderServices &) override;
void on_init_recovered(OrderRecord const &,
+1 -1
View File
@@ -1 +1 @@
set(sources ../../externals/linux/include/google/protobuf/descriptor.proto;../../externals/linux/include/google/protobuf/timestamp.proto;../lib/api/apicore.proto;../lib/api/apigateway.proto;../lib/api/apioptions.proto;../lib/api/services/AdminService.proto;../lib/api/services/ApiUnitTestService.proto;../lib/api/services/AuthService.proto;../lib/api/services/ErrorReportService.proto;../lib/api/services/HelloService.proto;../lib/api/services/MarketDataAuxiliaryService.proto;../lib/api/services/MarketDataRelay.proto;../lib/api/services/OrderService.proto;../lib/api/services/OutOfProcessURLListener.proto;../lib/api/services/PersistenceService.proto;../lib/api/services/PositionService.proto;../lib/api/services/ShellDiagnosticService.proto;../lib/api/services/ShellLatencyService.proto;../lib/api/services/SyntheticSecurityService.proto;../lib/domain_model/Security.proto;../lib/md/protos/co2.proto;../lib/sparkproto/SparkProtos.proto;api/build.sh;api/node_modules/cssstyle/scripts/run_tests.sh;api/node_modules/exit/test/fixtures/create-files.sh;api/node_modules/protobufjs/cli/node_modules/acorn-jsx/node_modules/acorn/bin/update_authors.sh;api/node_modules/watch/release.sh;api/quiet_build.sh;api/src/DynamicService.ts;api/src/ServiceContext.ts;api/src/bts_assert.ts;ui/src/Access.fs;ui/src/Accounts/ClipLimits.fs;ui/src/Accounts/ProductLimits.fs;ui/src/Accounts/SecurityLimits.fs;ui/src/Accounts/State.fs;ui/src/Accounts/Types.fs;ui/src/Accounts/View.fs;ui/src/App.fs;ui/src/Cmd.fs;ui/src/Controls/Button.fs;ui/src/Controls/DataGrid.fs;ui/src/Controls/Fields.fs;ui/src/Controls/Modal.fs;ui/src/Controls/ReactGrid.fs;ui/src/Controls/Table.fs;ui/src/Controls/nbsp.fs;ui/src/Global.fs;ui/src/Imports.fs;ui/src/Lens.fs;ui/src/Login/Login.fs;ui/src/Nav.fs;ui/src/State.fs;ui/src/Types.fs;ui/src/Users/State.fs;ui/src/Users/Types.fs;ui/src/Users/View.fs;ui/src/Util/EnumUtils.fs;ui/src/Util/JSMap.fs;ui/src/obj/Debug/netstandard2.0/ui.AssemblyInfo.fs)
set(sources ../../externals/linux/include/google/protobuf/descriptor.proto;../../externals/linux/include/google/protobuf/timestamp.proto;../lib/api/apicore.proto;../lib/api/apigateway.proto;../lib/api/apioptions.proto;../lib/api/services/AdminService.proto;../lib/api/services/ApiUnitTestService.proto;../lib/api/services/AuthService.proto;../lib/api/services/ErrorReportService.proto;../lib/api/services/HelloService.proto;../lib/api/services/MarketDataAuxiliaryService.proto;../lib/api/services/MarketDataRelay.proto;../lib/api/services/OrderService.proto;../lib/api/services/OutOfProcessURLListener.proto;../lib/api/services/PersistenceService.proto;../lib/api/services/PositionService.proto;../lib/api/services/ShellDiagnosticService.proto;../lib/api/services/ShellLatencyService.proto;../lib/api/services/SyntheticSecurityService.proto;../lib/domain_model/Security.proto;../lib/md/protos/co2.proto;../lib/sparkproto/SparkProtos.proto;api/build.sh;api/node_modules/exit/test/fixtures/create-files.sh;api/node_modules/protobufjs/cli/node_modules/acorn-jsx/node_modules/acorn/bin/update_authors.sh;api/node_modules/watch/release.sh;api/quiet_build.sh;api/src/DynamicService.ts;api/src/ServiceContext.ts;api/src/bts_assert.ts;ui/src/Access.fs;ui/src/Accounts/ClipLimits.fs;ui/src/Accounts/ProductLimits.fs;ui/src/Accounts/SecurityLimits.fs;ui/src/Accounts/State.fs;ui/src/Accounts/Types.fs;ui/src/Accounts/View.fs;ui/src/App.fs;ui/src/Cmd.fs;ui/src/Controls/Button.fs;ui/src/Controls/DataGrid.fs;ui/src/Controls/Fields.fs;ui/src/Controls/Modal.fs;ui/src/Controls/ReactGrid.fs;ui/src/Controls/Table.fs;ui/src/Controls/nbsp.fs;ui/src/Global.fs;ui/src/Imports.fs;ui/src/Lens.fs;ui/src/Login/Login.fs;ui/src/Nav.fs;ui/src/State.fs;ui/src/Types.fs;ui/src/Users/State.fs;ui/src/Users/Types.fs;ui/src/Users/View.fs;ui/src/Util/EnumUtils.fs;ui/src/Util/JSMap.fs;ui/src/obj/Debug/netstandard2.0/ui.AssemblyInfo.fs)