Iceberg with update

This commit is contained in:
Pedro Pinto committed 2019-02-11 16:50:35 -05:00
1 parent ad37a652c5
commit 836301e75f
8 files changed
+354 -157

No files matched your search

+1 -1
View File
@@ -21,7 +21,7 @@ service OrderService {
rpc update_order(Update) returns (Response)
{ option(skip_excel_generation) = true; };
rpc crack_order(Crack) returns (Response)
rpc detach_order(Crack) returns (Response)
{ option(skip_excel_generation) = true; };
rpc get_registered_dynamic_order_types(bts.api.VoidMessage)
@@ -102,22 +102,22 @@ class ChildOrder {
}
// End Update
// Crack
void crack() {
// Detach
void detach() {
bts_assert(_order);
bts_assert(_active);
_child_order_services->crack();
_child_order_services->detach();
}
template <class CB> void crack(CB const &on_result) {
template <class CB> void detach(CB const &on_result) {
bts_assert(_order);
bts_assert(_active);
auto on_result_w = [this, on_result](OrderOpResult const &r) {
_parent_order_services->call_with_reentrancy_guard(
[r, on_result](auto const &) { on_result(r); });
};
_child_order_services->crack(on_result);
_child_order_services->detach(on_result);
}
// End Crack
// End Detach
// Cancel
void cancel() {
@@ -276,7 +276,7 @@ void OrderManager::on_cancel_order(const mercury::Update<CancelOrderEvent> &m) {
}
}
void OrderManager::on_crack_order(const mercury::Update<CrackOrderEvent> &m) {
void OrderManager::on_detach_order(const mercury::Update<DetachOrderEvent> &m) {
if (m.events)
for (auto const &ev : *m.events) {
auto k = ev.key();
@@ -289,13 +289,13 @@ void OrderManager::on_crack_order(const mercury::Update<CrackOrderEvent> &m) {
};
if (it != me->orders.end())
it->second->_services->crack(on_order_op_result);
it->second->_services->detach(on_order_op_result);
else {
on_order_op_result(OrderOpResult{
api::orderman::ORDER_ERROR_UNKNOWN_ORDER, "Unknown Order"});
LOG(OrderMan, Error,
"Received a crack request for an unknown order {}. "
"Received a detach request for an unknown order {}. "
"This should not happen and likely indicates a serious bug. ",
ev.key().value());
}
@@ -436,8 +436,8 @@ void OrderManager::init_order_services() {
[this](auto const &ev) { this->on_update_order(ev); });
subscribe<CancelOrderEvent>(
[this](auto const &ev) { this->on_cancel_order(ev); });
subscribe<CrackOrderEvent>(
[this](auto const &ev) { this->on_crack_order(ev); });
subscribe<DetachOrderEvent>(
[this](auto const &ev) { this->on_detach_order(ev); });
// Clock
subscribe<mercury::TimerEvent>(
@@ -6,7 +6,7 @@
#include "lib/mercury/actors/IPollableActor.h"
#include "lib/orderman/events/ActivateOrderEvent.h"
#include "lib/orderman/events/CancelOrderEvent.h"
#include "lib/orderman/events/CrackOrderEvent.h"
#include "lib/orderman/events/DetachOrderEvent.h"
#include "lib/orderman/events/UpdateOrderEvent.h"
#include "lib/utils/inplace_function.h"
@@ -26,7 +26,7 @@ class NewExecutionReportEvent;
class ActivateOrderEvent;
class UpdateOrderEvent;
class CancelOrderEvent;
class CrackOrderEvent;
class DetachOrderEvent;
class StoredOrderEvent;
class StoredFillEvent;
class OrderServices;
@@ -57,7 +57,7 @@ namespace orderman {
// Additionally handles order maintenance events:
// - create
// - cancel
// - crack
// - detach
// - update
class OrderManager : public mercury::Actor, public mercury::IPollableActor {
@@ -78,7 +78,7 @@ class OrderManager : public mercury::Actor, public mercury::IPollableActor {
void on_activate_order(const mercury::Update<ActivateOrderEvent> &);
void on_update_order(const mercury::Update<UpdateOrderEvent> &);
void on_cancel_order(const mercury::Update<CancelOrderEvent> &);
void on_crack_order(const mercury::Update<CrackOrderEvent> &);
void on_detach_order(const mercury::Update<DetachOrderEvent> &);
void on_new_fix_buffer(const mercury::Update<CreateFIXBufferReplyEvent> &);
void on_gateway_state(const mercury::Update<GatewayStatusChangeEvent> &);
void on_timer(const mercury::Update<mercury::TimerEvent> &);
@@ -132,6 +132,7 @@ class OrderServices {
}
securities::ISecurityDB &sec_db() { return _data->sec_db; }
IOrderFactory &order_factory() { return _data->order_factory; }
mercury::TimeStampStr const &get_time_str() const {
return _data->last_timer_ev.ts_str;
@@ -318,8 +319,6 @@ class OrderServices {
}
}
IOrderFactory &order_factory() { return _data->order_factory; }
using CreateOrderReplySubID = EventStream<CreateOrderReplyEvent>::SubID;
template <class CB>
@@ -377,12 +376,12 @@ class OrderServices {
});
}
// Crack
void crack() {
// Detach
void detach() {
call_with_reentrancy_guard(
[](OrderServices &self) { self._owner->on_detach(self._do_nothing); });
}
void crack(OrderOpCallback const &on_order_op) {
void detach(OrderOpCallback const &on_order_op) {
call_with_reentrancy_guard([on_order_op](OrderServices &self) {
self._owner->on_detach(on_order_op);
});
@@ -14,7 +14,7 @@
#include "lib/orderman/events/TickerUpdateEvent.h"
#include "lib/orderman/events/CancelOrderEvent.h"
#include "lib/orderman/events/CancelRejectEvent.h"
#include "lib/orderman/events/CrackOrderEvent.h"
#include "lib/orderman/events/DetachOrderEvent.h"
#include "lib/orderman/events/CreateFIXBufferReplyEvent.h"
#include "lib/orderman/events/CreateFIXBufferRequestEvent.h"
#include "lib/orderman/events/CreateOrderReplyEvent.h"
+328 -133
View File
@@ -1,160 +1,355 @@
// #include "IcebergOrder2.h"
// #include "lib/orderman/actors/order_manager/ChildOrder.h"
// #include "lib/orderman/actors/order_manager/OrderBuilder.h"
#include "IcebergOrder2.h"
#include "lib/orderman/actors/order_manager/ChildOrder.h"
#include "lib/orderman/actors/order_manager/OrderBuilder.h"
// namespace bts {
// namespace orderman {
#include <algorithm>
// using namespace api::orderman;
namespace bts {
namespace orderman {
// enum class IcebergOrder2::State { PAUSED, WORKING, COMPLETED };
using namespace api::orderman;
enum class IcebergOrder2::State { PAUSED, WORKING, COMPLETED };
// struct IcebergOrder2::ActiveChild {
// ActiveChild() {}
// ChildOrder order;
struct IcebergOrder2::ActiveChild {
ActiveChild() {}
ChildOrder order;
// OrderState state;
// OrderKey key;
// void clear() {
// state = OrderState();
// key = null_order_key();
// }
// };
OrderState state;
OrderKey key;
void clear() {
state = OrderState();
key = null_order_key();
}
};
// struct IcebergOrder2::PImpl {
// OrderServices *services = nullptr;
// OrderDefinition def;
// OrderState order_state;
// OrderBuilder child_builder;
// ActiveChild child;
// State state = State::PAUSED;
// TimeStamp start_of_pause = Timer::now();
// uint32_t ms_pause_between_orders = 0;
// };
struct IcebergOrder2::PImpl {
OrderServices *services = nullptr;
OrderDefinition def;
OrderState order_state;
OrderBuilder child_builder;
ActiveChild child;
State state = State::PAUSED;
TimeStamp start_of_pause = Timer::now();
uint32_t ms_pause_between_orders = 0;
};
// IcebergOrder2::IcebergOrder2() : me(new PImpl()) {}
// IcebergOrder2::~IcebergOrder2() {}
IcebergOrder2::IcebergOrder2() : me(new PImpl()) {}
IcebergOrder2::~IcebergOrder2() {}
// void IcebergOrder2::on_init_new(OrderDefinition const &def,
// const PreActivationOrderServices &services) {
// // Save our order definition
// me->def = def;
void IcebergOrder2::on_init_new(OrderDefinition const &def,
const PreActivationOrderServices &services) {
// Save our order definition
me->def = def;
// // Initialize mutable iceberg component of our state report
// me->order_state.mutable_iceberg();
// Initialize mutable iceberg component of our state report
me->order_state.mutable_iceberg();
// auto &ib = iceberg_def();
auto &ib = iceberg_def();
// if (ib.show_quantity() == 0) {
// transition(State::COMPLETED, ORDER_STATUS_REJECTED_BY_SPARK,
// "Show quantity must be greater than 0");
// return;
// }
if (ib.show_quantity() == 0) {
transition(State::COMPLETED, ORDER_STATUS_REJECTED_BY_SPARK,
"Show quantity must be greater than 0");
return;
}
// initialize_child_builder(services.order_factory);
// }
initialize_child_builder(services.order_factory);
}
// void IcebergOrder2::on_init_recovered(OrderRecord const &rec,
// const PreActivationOrderServices &) {
// auto const &def = rec.def();
// me->def = def;
// me->order_state = rec.state();
void IcebergOrder2::on_init_recovered(OrderRecord const &rec,
const PreActivationOrderServices &) {
auto const &def = rec.def();
me->def = def;
me->order_state = rec.state();
// switch (me->order_state.status()) {
switch (me->order_state.status()) {
// case ORDER_STATUS_WORKING:
// case ORDER_STATUS_DISCONNECTED:
// transition(State::COMPLETED, ORDER_STATUS_REJECTED_BY_SPARK,
// "System restarted with active iceberg order");
// break;
case ORDER_STATUS_WORKING:
case ORDER_STATUS_DISCONNECTED:
transition(State::COMPLETED, ORDER_STATUS_REJECTED_BY_SPARK,
"System restarted with active iceberg order");
break;
// // terminal states
// case ORDER_STATUS_ERROR:
// case ORDER_STATUS_REJECTED_BY_SPARK:
// case ORDER_STATUS_COMPLETED:
// case ORDER_STATUS_CANCELED:
// transition(State::COMPLETED, rec.state().status(),
// rec.state().last_msg());
// break;
// terminal states
case ORDER_STATUS_ERROR:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_COMPLETED:
case ORDER_STATUS_CANCELED:
transition(State::COMPLETED, rec.state().status(),
rec.state().last_msg());
break;
// case ORDER_STATUS_PENDING_WORKING:
// case ORDER_STATUS_INACTIVE:
// case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
// case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
// bts_assert(false);
// break;
// }
// }
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_INACTIVE:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
}
// OrderOpResult IcebergOrder2::on_activate(Price p, Quantity q, OrderServices &services) {
// bts_assert(!me->services);
// me->services = &services;
// me->child_builder.activate(services);
OrderOpResult IcebergOrder2::on_activate(Price p, Quantity q,
OrderServices &services) {
bts_assert(!me->services);
me->services = &services;
me->child_builder.activate(services);
// switch (me->state) {
// case State::PAUSED:
// me->order_state.set_price(p.value());
// me->order_state.set_quantity(q.value());
// services.subscribe_to_time(
// [this](auto const &time) { this->on_time(time); });
// services.subscribe_to_child_updates(
// [this](auto const &os) { this->on_child_order_update(os); });
// send_next_child_order();
// break;
switch (me->state) {
case State::PAUSED:
me->order_state.set_price(p.value());
me->order_state.set_quantity(q.value());
if (q.value()) {
services.subscribe_to_time(
[this](auto const &time) { this->on_time(time); });
services.subscribe_to_child_updates(
[this](auto const &os) { this->on_child_order_update(os); });
send_next_child_order();
} else
transition(State::COMPLETED, ORDER_STATUS_COMPLETED);
case State::COMPLETED:
break;
case State::WORKING:
bts_assert(false);
break;
}
report_state();
return OrderOpResult{};
}
// case State::COMPLETED:
// break;
// case State::WORKING:
// bts_assert(false);
// break;
// }
// report_state();
// cb(OrderOpResult{});
// }
OrderOpResult IcebergOrder2::on_update(api::orderman::Update const &update) {
auto result = OrderOpResult{};
// OrderOpResult IcebergOrder2::on_update(api::orderman::Update const &update) {
// switch (me->state) {
// case State::PAUSED:
// case State::WORKING:
// if (update.has_custom() && !update.custom().has_iceberg())
// cb(OrderOpResult{ORDER_ERROR_INVALID_OP,
// "Update is not valid for this order type"});
// else {
// auto &ib_update = update.custom().iceberg();
// if (ib_update.show_quantity() == 0)
// cb(OrderOpResult{ORDER_ERROR_INVALID_OP,
// "Show quantity must be greater than 0"});
// else {
// me->order_state.set_price(update.price());
// me->order_state.set_quantity(update.quantity());
// }
switch (me->state) {
case State::PAUSED:
case State::WORKING:
if (update.has_custom() && !update.custom().has_iceberg()) {
result = OrderOpResult{ORDER_ERROR_INVALID_OP,
"Update is not valid for this order type"};
break;
}
// break;
if (update.has_custom()) {
auto &ib_update = update.custom().iceberg();
if (ib_update.show_quantity() == 0) {
result = OrderOpResult{ORDER_ERROR_INVALID_OP,
"Show quantity must be greater than 0"};
break;
}
*me->def.mutable_custom_def() = update.custom();
me->services->report_definition(me->def.custom_def());
initialize_child_builder(me->services->order_factory());
}
me->order_state.set_price(update.price());
me->order_state.set_quantity(update.quantity());
break;
// case State::COMPLETED:
// break;
// break;
// }
// }
case State::COMPLETED:
result =
OrderOpResult{ORDER_ERROR_INVALID_OP, "Order is already completed"};
break;
}
report_state();
return result;
}
// IcebergOrderDefinition &IcebergOrder2::iceberg_def() {
// return *me->def.mutable_custom_def()->mutable_iceberg();
// }
void IcebergOrder2::on_child_order_update(OrderStateUpdateEvent const &ev) {
switch (me->state) {
case State::PAUSED:
if (ev.key == me->child.key) {
me->child.state = ev.rebuild_state();
// void IcebergOrder2::initialize_child_builder(IOrderFactory &of) {
// // Copy parent definition to child, so the child inherits all the
// // standard properties of the parent (side, security, TIF, etc)
// auto child_def = me->def;
// // Copy the custom part of the child order definition to our child
// *child_def.mutable_custom_def() = iceberg_def().child();
switch (ev.status) {
// // Build our child builder
// me->child_builder = OrderBuilder(key(), child_def, of, 1);
// if (me->services)
// me->child_builder.activate(*me->services);
// }
case ORDER_STATUS_WORKING:
case ORDER_STATUS_PENDING_WORKING:
// nothing to do but report new state
break;
// } // namespace orderman
// } // namespace bts
case ORDER_STATUS_COMPLETED: {
api::orderman::OrderState merged_state;
merge_states(me->order_state, me->child.state, &merged_state);
me->order_state = merged_state;
me->child.clear();
if (me->state.quantity() > me->state.filled_quantity()) {
if (me->pause_between_orders) {
me->working_sub_status = WorkingSubStatus::PAUSED;
me->start_of_pause = Timer::now();
} else
send_next_child_order();
} else
transition(ORDER_STATUS_COMPLETED);
break;
}
case ORDER_STATUS_CANCELED:
LOG(OrderMan, Info,
"Unexpected cancel of child {} in Iceberg Order {}. Canceling "
"parent",
ev.key.value(), key().value());
transition(ORDER_STATUS_CANCELED);
break;
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_ERROR:
me->child.clear();
transition(ORDER_STATUS_ERROR, "Unexpected child order state");
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;
}
} else {
LOG(OrderMan, Info,
"Iceberg order {} received update for non active child order {}."
"update state = {}",
key().value(), me->child.key.value(),
utils::pb::to_string(ev.rebuild_state()));
}
break;
case ORDER_STATUS_CANCELED:
case ORDER_STATUS_ERROR:
case ORDER_STATUS_DISCONNECTED:
case ORDER_STATUS_COMPLETED:
break;
case ORDER_STATUS_PENDING_WORKING:
case ORDER_STATUS_REJECTED_BY_SPARK:
case ORDER_STATUS_INACTIVE:
case OrderStatus_INT_MIN_SENTINEL_DO_NOT_USE_:
case OrderStatus_INT_MAX_SENTINEL_DO_NOT_USE_:
bts_assert(false);
break;
}
report_state();
}
void IcebergOrder2::transition(State state, api::orderman::OrderStatus status,
std::string const &msg) {
LOG(OrderMan, Info, "Transitioning iceberg order {} from {} to {}",
key().value(), std::string(state_name(me->state)),
std::string(state_name(state)));
me->state = state;
me->order_state.set_status(status);
me->order_state.set_last_msg(msg);
}
void IcebergOrder2::report_state() {
if (me->child.state.filled_quantity()) {
api::orderman::OrderState merged_state;
merge_states(me->order_state, me->child.state, &merged_state);
me->services->report_state(merged_state);
} else
me->services->report_state(me->order_state);
}
IcebergOrderDefinition &IcebergOrder2::iceberg_def() {
return *me->def.mutable_custom_def()->mutable_iceberg();
}
OrderOpResult IcebergOrder2::on_cancel() {
switch (me->state) {
case State::PAUSED:
transition(State::COMPLETED, ORDER_STATUS_CANCELED);
return OrderOpResult{};
case State::WORKING:
me->child.order.cancel();
transition(State::COMPLETED, ORDER_STATUS_CANCELED);
return OrderOpResult{};
case State::COMPLETED:
return OrderOpResult{ORDER_ERROR_INVALID_OP,
"Order is already completed"};
}
}
void IcebergOrder2::send_next_child_order() {
bts_assert(me->order_state.quantity() > me->order_state.filled_quantity());
auto remaining =
me->order_state.quantity() - me->order_state.filled_quantity();
auto to_send = std::min(remaining, (uint32_t)iceberg_def().show_quantity());
me->child.order = me->child_builder.build();
me->child.key = me->child.order.key();
LOG(OrderMan, Info,
"Iceberg order {} creating new child order {} with size "
"{} price {}. Filled {} so far out of {}",
key().value(), me->child.key.value(), to_send, me->order_state.price(),
me->order_state.filled_quantity(), me->order_state.quantity());
me->child.order.activate(
Price(me->order_state.price()), Quantity(to_send),
[this](auto const &op) { this->on_order_op_completed(op); });
}
void IcebergOrder2::on_order_op_completed(OrderOpResult r) {
if (r.error == ORDER_ERROR_OK)
return;
switch (me->state) {
case State::PAUSED:
transition(State::COMPLETED, ORDER_STATUS_ERROR,
std::string ("Child order operation failed: ") +
r.error_msg);
break;
case State::WORKING:
me->child.order.cancel();
transition(State::COMPLETED, ORDER_STATUS_ERROR,
std::string ("Child order operation failed: ") +
r.error_msg);
break;
case State::COMPLETED:
break;
}
}
void IcebergOrder2::initialize_child_builder(IOrderFactory &of) {
// Copy parent definition to child, so the child inherits all the
// standard properties of the parent (side, security, TIF, etc)
auto child_def = me->def;
// Copy the custom part of the child order definition to our child
*child_def.mutable_custom_def() = iceberg_def().child();
// Build our child builder
me->child_builder = OrderBuilder(key(), child_def, of, 1);
if (me->services)
me->child_builder.activate(*me->services);
}
void IcebergOrder2::merge_states(api::orderman::OrderState const &iceberg_state,
api::orderman::OrderState const &child_state,
api::orderman::OrderState *merged) {
auto child_order_fills = child_state.filled_quantity();
auto child_order_avg_price = child_state.avg_price();
auto child_order_last_price = child_state.last_price();
auto iceberg_fills = iceberg_state.filled_quantity();
auto iceberg_avg_price = iceberg_state.avg_price();
*merged = iceberg_state;
merged->set_filled_quantity(child_order_fills + iceberg_fills);
merged->set_last_price(child_order_last_price);
merged->set_avg_price((child_order_fills * child_order_avg_price +
iceberg_fills * iceberg_avg_price) /
(child_order_fills + iceberg_fills));
}
const char *IcebergOrder2::state_name(State st) {
switch (st) {
case State::PAUSED:
return "PAUSED";
case State::COMPLETED:
return "COMPLETED";
case State::WORKING:
return "WORKING";
}
}
} // namespace orderman
} // namespace bts
+5 -2
View File
@@ -31,11 +31,9 @@ class IcebergOrder2 : public Order {
const PreActivationOrderServices &) override;
OrderOpResult on_activate(Price, Quantity, OrderServices &) override;
OrderOpResult on_update(api::orderman::Update const &) override;
OrderOpResult on_detach() override;
OrderOpResult on_cancel() override;
private:
enum class State;
struct ActiveChild;
struct PImpl;
@@ -47,6 +45,11 @@ class IcebergOrder2 : public Order {
void on_child_order_update(OrderStateUpdateEvent const &ev);
void report_state();
void send_next_child_order();
const char* state_name (State);
void merge_states(api::orderman::OrderState const &iceberg_state,
api::orderman::OrderState const &child_state,
api::orderman::OrderState *merged);
void on_order_op_completed(OrderOpResult);
};
} // namespace orderman