#include "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 { 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; bool is_recovered; bool is_succ_inited; double tick_size; uint16_t n_orders; api::orderman::OrderState state; OrderBuilder order_builder; Book book; //0th entry is the top order (most aggressive) std::vector orders; PImpl() : services(nullptr), order_def() {} }; QueueHolderOrder::QueueHolderOrder() : _state(State::START), me(new PImpl()) {} QueueHolderOrder::~QueueHolderOrder() {} const api::orderman::OrderDefinition &QueueHolderOrder::definition() const { return me->order_def; } 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; } } void QueueHolderOrder::on_init_recovered( const api::orderman::OrderRecord&, const PreActivationOrderServices&) { } void QueueHolderOrder::on_activate( Price price, Quantity qty, OrderServices& services, 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; } } } // order price, qty change void QueueHolderOrder::on_update(Price, Quantity, const trace::CorID&) { } void QueueHolderOrder::on_crack(trace::CorID const &) { } void QueueHolderOrder::on_cancel(const trace::CorID&) { } void QueueHolderOrder::_on_book_update(const BookUpdateEvent&) { } 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())); } } void QueueHolderOrder::_report_state() { } void QueueHolderOrder::_switch_state(State) { } } // namespace orderman } // namespace bts