From 0bbf58638e4e8be806b8959d4d5dd7ddee542b9e Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 4 Feb 2019 09:04:19 -0500 Subject: [PATCH] added more logic to QueueHolderOrderStartStateWorker --- .../orders/queue_holder/QueueHolderOrder.cpp | 158 ++++-------------- .../orders/queue_holder/QueueHolderOrder.h | 52 +++--- .../QueueHolderOrderStartStateWorker.cpp | 98 +++++++++-- .../QueueHolderOrderStartStateWorker.h | 7 +- .../queue_holder/QueueHolderOrderSubOrder.h | 22 +++ 5 files changed, 168 insertions(+), 169 deletions(-) create mode 100644 src/lib/orderman/orders/queue_holder/QueueHolderOrderSubOrder.h diff --git a/src/lib/orderman/orders/queue_holder/QueueHolderOrder.cpp b/src/lib/orderman/orders/queue_holder/QueueHolderOrder.cpp index 686974040..4a8ee3560 100644 --- a/src/lib/orderman/orders/queue_holder/QueueHolderOrder.cpp +++ b/src/lib/orderman/orders/queue_holder/QueueHolderOrder.cpp @@ -13,32 +13,6 @@ namespace bts { namespace orderman { -class SubOrder{ -public: - ChildOrder order; - // position in the order list - uint16_t pos; - // last sent price - Price out_price; - // last send qty - Quantity out_qty; - // last received status - api::orderman::OrderStatus status; - // total fills - uint32_t filled_quantity; - // avg filled price - double avg_price; - SubOrder() - : - order(), - out_price(bts::os::nan()), - out_qty(0), - status(api::orderman::OrderStatus::ORDER_STATUS_INACTIVE), - filled_quantity(0), - avg_price(bts::os::nan()) - {} -}; - struct QueueHolderOrder::PImpl { OrderServices *services; api::orderman::OrderDefinition order_def; @@ -50,7 +24,6 @@ struct QueueHolderOrder::PImpl { OrderBuilder order_builder; Book book; //0th entry is the top order (most aggressive) - std::vector orders; PImpl() : services(nullptr), @@ -59,8 +32,19 @@ struct QueueHolderOrder::PImpl { }; QueueHolderOrder::QueueHolderOrder() -: -_state(State::START), +: +_services(nullptr), +_order_def(), +_is_recovered(false), +_is_succ_inited(false), +_tick_size(bts::os::nan()), +_n_orders(0), +_reported_state(), +_order_builder(), +_book(), +_orders(), +_state_worker(nullptr), +_start_state_worker(this), me(new PImpl()) {} QueueHolderOrder::~QueueHolderOrder() {} const api::orderman::OrderDefinition &QueueHolderOrder::definition() const { @@ -69,24 +53,15 @@ const api::orderman::OrderDefinition &QueueHolderOrder::definition() const { void QueueHolderOrder::on_init_new(const api::orderman::OrderDefinition& order_def, const PreActivationOrderServices& pre_os) { LOG(OrderMan, Info, "QueueHolderOrder::on_init_new key:{} state:{}", - key(), _state); - switch (_state) { - case State::START: - me->is_succ_inited = _on_init_new(order_def, pre_os); - break; - case State::WAITING_FOR_FIRST_ACK: - case State::WORKING: - case State::WAITING_FOR_CANCEL_ALL: - case State::END: - std::ostringstream oss; - oss << "QueueHolderOrder::on_init_new key:" << key() << "state:" << _state; - bts_assert_msg(false, oss.str()); - break; - } + key(), _state_int()); + _state_worker->on_init_new(order_def,pre_os); } void QueueHolderOrder::on_init_recovered( - const api::orderman::OrderRecord&, - const PreActivationOrderServices&) { + const api::orderman::OrderRecord& rec, + const PreActivationOrderServices& pre_os) { + LOG(OrderMan, Info, "QueueHolderOrder::on_init_recovered key:{} state:{}", + key(), _state_int()); + _state_worker->on_init_recovered(rec,pre_os); } void QueueHolderOrder::on_activate( Price price, @@ -95,45 +70,8 @@ void QueueHolderOrder::on_activate( const trace::CorID&) { LOG(OrderMan, Info, "QueueHolderOrder::on_activate key:{} state:{} price:{} qty:{}", - key(), _state, price, qty); - switch (_state) { - case State::START: - me->services = &services; - me->state.set_price(price.value()); - me->state.set_quantity(qty.value()); - if (me->is_recovered || !me->is_succ_inited) - _switch_state(State::END); - else { - me->order_builder.activate(services); - for(uint16_t i=0;in_orders;i++){ - me->orders.emplace_back(); - SubOrder& new_it=me->orders.back(); - new_it.order=me->order_builder.build(); - } - services.subscribe_to_child_updates( - [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); - }); - services.subscribe_to_time( - [this](const bts::mercury::TimerEvent &te) { _on_time(te); }); - _send_initial_orders(); - _switch_state(State::WAITING_FOR_FIRST_ACK); - } - break; - case State::WAITING_FOR_FIRST_ACK: - case State::WORKING: - case State::WAITING_FOR_CANCEL_ALL: - case State::END: { - std::ostringstream oss; - oss << "QueueHolderOrder::on_activate key:" << key() << "state:" << _state; - bts_assert_msg(false, oss.str()); - break; - } - } + key(), _state_int(), price, qty); + _state_worker->on_activate(price,qty,services); } // order price, qty change void QueueHolderOrder::on_update(Price, @@ -150,53 +88,21 @@ void QueueHolderOrder::_on_child_order_update(const OrderStateUpdateEvent&) { } void QueueHolderOrder::_on_time(const bts::mercury::TimerEvent&) { } -bool QueueHolderOrder::_on_init_new( - const api::orderman::OrderDefinition& order_def, - const PreActivationOrderServices& pre_os) { - me->order_def = order_def; - if (!me->order_def.has_custom_def() || - !me->order_def.custom_def().has_queue_holder()) { - LOG(OrderMan, Error, - "QueueHolderOrder::_on_init_new key:{} " - "OrderDefinition does not have QueueHolderDefinition", - key()); - me->state.set_last_msg("QueueHolderOrder not properly formed"); - return false; - } - const bts::api::Security* sec_ptr = - pre_os.sec_db.resolve(SecurityKey(order_def.security_key())); - if (sec_ptr==nullptr) { - LOG(OrderMan, Error, - "QueueHolderOrder::_on_init_new key:{} state:{} " - "Could not resolve sec_key:{}", - key(), _state, order_def.security_key()); - me->state.set_last_msg("Could not resolve Trigger Order security"); - return false; - } - const api::orderman::QueueHolderDefinition& qh_def=me->order_def.custom_def().queue_holder(); - api::orderman::OrderDefinition child_order_def = order_def; - child_order_def.mutable_custom_def()->CopyFrom(qh_def.child()); - me->order_builder = OrderBuilder(key(), child_order_def, pre_os); - LOG(OrderMan, Info, - "QueueHolderOrder::_on_init_new key:{} state:{} ", - key(), _state); - return true; -} void QueueHolderOrder::_send_initial_orders(){ - double mult = me->order_def.side()==api::Side::SIDE_BUY ? -1 : 1; - for(uint16_t i=0;in_orders;i++){ - double price=me->state.price()+mult*i*me->tick_size; - SubOrder& order=me->orders.at(i); - order.order.activate(Price(price),Quantity(me->state.quantity())); - } + // double mult = me->order_def.side()==api::Side::SIDE_BUY ? -1 : 1; + // for(uint16_t i=0;in_orders;i++){ + // double price=me->state.price()+mult*i*me->tick_size; + // SubOrder& order=me->orders.at(i); + // order.order.activate(Price(price),Quantity(me->state.quantity())); + // } } -void QueueHolderOrder::_cancel_orders(){ - for(auto& sub_ord : me->orders) - sub_ord.order.cancel(); +void QueueHolderOrder::_cancel_orders(){ + for(auto& sub_ord : _orders) + sub_ord.order.cancel_order(); } void QueueHolderOrder::_report_state() { } -void QueueHolderOrder::_switch_state(State) { +void QueueHolderOrder::_switch_state(QueueHolderOrderState) { } } // namespace orderman diff --git a/src/lib/orderman/orders/queue_holder/QueueHolderOrder.h b/src/lib/orderman/orders/queue_holder/QueueHolderOrder.h index 5aacb2683..3b82cf736 100644 --- a/src/lib/orderman/orders/queue_holder/QueueHolderOrder.h +++ b/src/lib/orderman/orders/queue_holder/QueueHolderOrder.h @@ -4,6 +4,8 @@ #include "lib/orderman/orders/Order.h" #include "lib/api/services/OrderService.server.pb.h" #include "lib/orderman/orders/queue_holder/IQueueHolderOrderStateWorker.h" +#include "lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.h" +#include "lib/orderman/orders/queue_holder/QueueHolderOrderSubOrder.h" namespace bts { namespace api {namespace orderman {class OrderDefinition;}} @@ -17,27 +19,7 @@ class PreActivationOrderServices; class QueueHolderOrder : public Order { -private: - -enum State{ - // remains here till on_activate is called - START=0, - // once the order is submitted it gets into - // this state until it gets an ack on all - // the queue orders - WAITING_FOR_FIRST_ACK=1, - // before all orders are acked, - // the order is cancelled - //WAITING_FOR_FIRST_ACK_CANCELLED=2, - // all orders are ack'ed, free to accept - // updates - WORKING=3, - // cancel has been sent, wait for all - // queue orders to be in final state - WAITING_FOR_CANCEL_ALL=4, - // final state, no going back - END=5 -}; +friend QueueHolderOrderStartStateWorker; public: QueueHolderOrder(); ~QueueHolderOrder(); @@ -57,22 +39,36 @@ private: void _on_book_update(const BookUpdateEvent&); void _on_child_order_update(OrderStateUpdateEvent const&); void _on_time (const bts::mercury::TimerEvent&); -private: - // called from init_new - bool _on_init_new(const api::orderman::OrderDefinition& order_def, - const PreActivationOrderServices& pre_os); +private: + const QueueHolderOrderState _state() const{ + return _state_worker->state(); + } + const int _state_int() const{ + return static_cast(_state_worker->state()); + } // sends orders for the first time void _send_initial_orders(); void _cancel_orders(); void _report_state(); - void _switch_state(State new_state); + void _switch_state(QueueHolderOrderState new_state); bool _activated() const; //returns true is p1 >= p2 static bool _gr_than_eq(double p1, double p2, double tick_size); private: - State _state; + OrderServices *_services; + api::orderman::OrderDefinition _order_def; + bool _is_recovered; + bool _is_succ_inited; + double _tick_size; + uint16_t _n_orders; + api::orderman::OrderState _reported_state; + OrderBuilder _order_builder; + Book _book; + std::vector _orders; + IQueueHolderOrderStateWorker* _state_worker; + QueueHolderOrderStartStateWorker _start_state_worker; struct PImpl; std::unique_ptr me; }; -}} +}} \ No newline at end of file diff --git a/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.cpp b/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.cpp index 3f6f218d7..acdf57ed2 100644 --- a/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.cpp +++ b/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.cpp @@ -1,4 +1,15 @@ #include "lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.h" +#include "lib/orderman/orders/queue_holder/QueueHolderOrder.h" +#include "lib/domain_model/Security.h" +#include "lib/logging/logging.h" +#include "lib/orderman/actors/order_manager/OrderBuilder.h" +#include "lib/orderman/events/BookUpdateEvent.h" +#include "lib/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" +#include "lib/os/os.h" +#include "lib/utils/PBUtils.h" +#include +#include +#include "lib/os/os.h" namespace bts{ namespace orderman{ @@ -13,28 +24,93 @@ void QueueHolderOrderStartStateWorker::on_transition (){ } void QueueHolderOrderStartStateWorker::on_init_new( - const api::orderman::OrderDefinition&, - const PreActivationOrderServices&){ + const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os){ + _on_init_new(order_def, pre_os); } void QueueHolderOrderStartStateWorker::on_init_recovered( const bts::api::orderman::OrderRecord&, - const PreActivationOrderServices&){ + const PreActivationOrderServices&){ } -void QueueHolderOrderStartStateWorker::on_activate(Price, - Quantity, - OrderServices&){ +void QueueHolderOrderStartStateWorker::on_activate(Price price, + Quantity qty, + OrderServices& services){ + api::orderman::OrderState& state=_parent->_reported_state; + _parent->_services = &services; + state.set_price(price.value()); + state.set_quantity(qty.value()); + if (_parent->_is_recovered || !_parent->_is_succ_inited) + _parent->_switch_state(QueueHolderOrderState::END); + else { + _parent->_order_builder.activate(services); + for(uint16_t i=0;_parent->_n_orders;i++){ + ChildOrder order=_parent->_order_builder.build(); + _parent->_orders.emplace_back(order, + SecurityKey(_parent->_order_def.security_key())); + } + services.subscribe_to_child_updates( + [this](const OrderStateUpdateEvent &os) { + _parent->_on_child_order_update(os); + }); + services.subscribe_to_book(SecurityKey(_parent->_order_def.security_key()), + [this](const BookUpdateEvent &bk_event) { + _parent->_on_book_update(bk_event); + }); + services.subscribe_to_time( + [this](const bts::mercury::TimerEvent &te) { _parent->_on_time(te); }); + _parent->_send_initial_orders(); + _parent->_switch_state(QueueHolderOrderState::WAITING_FOR_FIRST_ACK); + } } -void QueueHolderOrderStartStateWorker::on_update(Price, +void QueueHolderOrderStartStateWorker::on_update(Price, Quantity){ + bts_assert_msg (false, "QueueHolderOrderStartStateWorker::on_update " + "is an illegal operation"); } -void QueueHolderOrderStartStateWorker::on_cancel(){ +void QueueHolderOrderStartStateWorker::on_cancel(){ + _parent->_switch_state(QueueHolderOrderState::END); } void QueueHolderOrderStartStateWorker::on_child_order_update( - const OrderStateUpdateEvent&){ + const OrderStateUpdateEvent&){ + bts_assert_msg (false, "QueueHolderOrderStartStateWorker::on_child_order_update " + "is an illegal operation"); } void QueueHolderOrderStartStateWorker::on_book(const Book&, const trace::CorID&){ } -void QueueHolderOrderStartStateWorker::on_time(const TimeStamp&){ +void QueueHolderOrderStartStateWorker::on_time(const TimeStamp&){ } -}} +bool QueueHolderOrderStartStateWorker::_on_init_new( + const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os) { + _parent->_order_def = order_def; + if (!order_def.has_custom_def() || + !order_def.custom_def().has_queue_holder()) { + LOG(OrderMan, Error, + "QueueHolderOrderStartStateWorker::_on_init_new key:{} " + "OrderDefinition does not have QueueHolderDefinition", + _parent->key()); + _parent->_reported_state.set_last_msg("QueueHolderOrder not properly formed"); + return false; + } + const bts::api::Security* sec_ptr = + pre_os.sec_db.resolve(SecurityKey(order_def.security_key())); + if (sec_ptr==nullptr) { + LOG(OrderMan, Error, + "QueueHolderOrderStartStateWorker::_on_init_new key:{} " + "Could not resolve sec_key:{}", + _parent->key(), order_def.security_key()); + _parent->_reported_state.set_last_msg("Could not resolve Trigger Order security"); + return false; + } + const api::orderman::QueueHolderDefinition& + qh_def=order_def.custom_def().queue_holder(); + api::orderman::OrderDefinition child_order_def = order_def; + child_order_def.mutable_custom_def()->CopyFrom(qh_def.child()); + _parent->_order_builder = OrderBuilder(_parent->key(), child_order_def, pre_os); + LOG(OrderMan, Info, + "QueueHolderOrderStartStateWorker::_on_init_new key:{} ", + _parent->key()); + return true; +} +}} \ No newline at end of file diff --git a/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.h b/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.h index 4c5dc0b8d..e86315464 100644 --- a/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.h +++ b/src/lib/orderman/orders/queue_holder/QueueHolderOrderStartStateWorker.h @@ -29,15 +29,14 @@ public: const PreActivationOrderServices&) override; void on_activate(Price, Quantity, OrderServices&) override; void on_update(Price, Quantity) override; - // 5. called when the user cancels an order void on_cancel() override; - // 6. order callback void on_child_order_update(const OrderStateUpdateEvent&) override; - // 7. on market data update (support late joiners) void on_book(const Book&, const trace::CorID&) override; - // 8. time event called by the infrastructure void on_time(const TimeStamp&) override; +private: + bool _on_init_new(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os); }; }} \ No newline at end of file diff --git a/src/lib/orderman/orders/queue_holder/QueueHolderOrderSubOrder.h b/src/lib/orderman/orders/queue_holder/QueueHolderOrderSubOrder.h new file mode 100644 index 000000000..625d5443f --- /dev/null +++ b/src/lib/orderman/orders/queue_holder/QueueHolderOrderSubOrder.h @@ -0,0 +1,22 @@ +#pragma once + +#include "lib/orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.h" + +namespace bts { +namespace orderman { + +class QueueHolderOrderSubOrder{ +public: + SpreaderChildOrderState order; + // position in the order list + uint16_t pos; + QueueHolderOrderSubOrder(ChildOrder& child_order, + SecurityKey sec_key) + : + order(sec_key,true,true), + pos(0){ + order.re_init(child_order); + } + +}; +}} \ No newline at end of file