diff --git a/src/lib/api/services/OrderService.proto b/src/lib/api/services/OrderService.proto index 23637e201..ddd2f512f 100644 --- a/src/lib/api/services/OrderService.proto +++ b/src/lib/api/services/OrderService.proto @@ -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) diff --git a/src/lib/orderman/actors/order_manager/ChildOrder.h b/src/lib/orderman/actors/order_manager/ChildOrder.h index 7052eaffe..603691055 100644 --- a/src/lib/orderman/actors/order_manager/ChildOrder.h +++ b/src/lib/orderman/actors/order_manager/ChildOrder.h @@ -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 void crack(CB const &on_result) { + template 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() { diff --git a/src/lib/orderman/actors/order_manager/OrderManager.cpp b/src/lib/orderman/actors/order_manager/OrderManager.cpp index 7d2ec70ed..d2fbd3168 100644 --- a/src/lib/orderman/actors/order_manager/OrderManager.cpp +++ b/src/lib/orderman/actors/order_manager/OrderManager.cpp @@ -276,7 +276,7 @@ void OrderManager::on_cancel_order(const mercury::Update &m) { } } -void OrderManager::on_crack_order(const mercury::Update &m) { +void OrderManager::on_detach_order(const mercury::Update &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 &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( [this](auto const &ev) { this->on_cancel_order(ev); }); - subscribe( - [this](auto const &ev) { this->on_crack_order(ev); }); + subscribe( + [this](auto const &ev) { this->on_detach_order(ev); }); // Clock subscribe( diff --git a/src/lib/orderman/actors/order_manager/OrderManager.h b/src/lib/orderman/actors/order_manager/OrderManager.h index 2489f5b11..461705c1f 100644 --- a/src/lib/orderman/actors/order_manager/OrderManager.h +++ b/src/lib/orderman/actors/order_manager/OrderManager.h @@ -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 &); void on_update_order(const mercury::Update &); void on_cancel_order(const mercury::Update &); - void on_crack_order(const mercury::Update &); + void on_detach_order(const mercury::Update &); void on_new_fix_buffer(const mercury::Update &); void on_gateway_state(const mercury::Update &); void on_timer(const mercury::Update &); diff --git a/src/lib/orderman/actors/order_manager/OrderServices.h b/src/lib/orderman/actors/order_manager/OrderServices.h index 914ba5b15..d8290fc4c 100644 --- a/src/lib/orderman/actors/order_manager/OrderServices.h +++ b/src/lib/orderman/actors/order_manager/OrderServices.h @@ -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::SubID; template @@ -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); }); diff --git a/src/lib/orderman/actors/order_manager/OrderServicesData.h b/src/lib/orderman/actors/order_manager/OrderServicesData.h index 00c50cb98..97c47acb8 100644 --- a/src/lib/orderman/actors/order_manager/OrderServicesData.h +++ b/src/lib/orderman/actors/order_manager/OrderServicesData.h @@ -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" diff --git a/src/lib/orderman/orders/IcebergOrder2.cpp b/src/lib/orderman/orders/IcebergOrder2.cpp index b1a782911..58e12968e 100644 --- a/src/lib/orderman/orders/IcebergOrder2.cpp +++ b/src/lib/orderman/orders/IcebergOrder2.cpp @@ -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 -// 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 diff --git a/src/lib/orderman/orders/IcebergOrder2.h b/src/lib/orderman/orders/IcebergOrder2.h index ffe0e7975..f22297007 100644 --- a/src/lib/orderman/orders/IcebergOrder2.h +++ b/src/lib/orderman/orders/IcebergOrder2.h @@ -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