#include "QueueHolderOrder.h" #include "lib/domain_model/Security.h" #include "lib/logging/logging.h" #include "lib/orderman/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 namespace bts { namespace orderman { QueueHolderOrder::QueueHolderOrder() : _is_succ_inited(false), _is_recovered(false), _termination_reason(TerminationReason::NONE), _order_def(), _tick_size(bts::os::nan()), _order_builder(), _order_manager(), _services(nullptr), _reported_state(), _sent_state(), _book(), _state_worker(nullptr), _start_state_worker(this), _waiting_for_ack_state_worker(this), _working_state_worker(this), _waiting_for_cancel_all_state_worker(this), _end_state_worker(this) { _switch_state(QueueHolderOrderState::START); } QueueHolderOrder::~QueueHolderOrder() {} const api::orderman::OrderDefinition &QueueHolderOrder::definition() const { return _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_int()); _state_worker->on_init_new(order_def, pre_os); } void QueueHolderOrder::on_init_recovered( 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); } OrderOpResult QueueHolderOrder::on_activate( Price price, Quantity qty, OrderServices &services) { LOG(OrderMan, Info, "QueueHolderOrder::on_activate key:{} state:{} price:{} qty:{}", key(), _state_int(), price, qty); _state_worker->on_activate(price, qty, services); _report_state(); return OrderOpResult{}; } // order price, qty change OrderOpResult QueueHolderOrder::on_update(Price price, Quantity qty) { _state_worker->on_update(price, qty); _report_state(); return OrderOpResult{}; } OrderOpResult QueueHolderOrder::on_cancel() { LOG(OrderMan, Info, "QueueHolderOrder::on_cancel key:{} state:{}", key(), _state_int()); _state_worker->on_cancel(); _report_state(); return OrderOpResult{}; } OrderOpResult QueueHolderOrder::on_detach() { return OrderOpResult{}; } void QueueHolderOrder::_on_book_update(const BookUpdateEvent &b) { _state_worker->on_book(b.book, b.trace); } void QueueHolderOrder::_on_child_order_update(const OrderStateUpdateEvent &c) { LOG(OrderMan, Diag, "QueueHolderOrder::_on_child_order_update key:{} state:{} " "order_key:{} order_state:{}", key(), _state_int(), c.key, c.status); _state_worker->on_child_order_update(c); _report_state(); } void QueueHolderOrder::_on_time(const bts::mercury::TimerEvent &te) { _state_worker->on_time(te.ts); } void QueueHolderOrder::_switch_state(QueueHolderOrderState new_state) { int s0 = _state_int(); switch (new_state) { case QueueHolderOrderState::START: bts_assert(_state_worker == nullptr); _state_worker = &_start_state_worker; break; case QueueHolderOrderState::WAITING_FOR_FIRST_ACK: bts_assert( _state_worker->state() == QueueHolderOrderState::START || _state_worker->state() == QueueHolderOrderState::WORKING); _state_worker = &_waiting_for_ack_state_worker; break; case QueueHolderOrderState::WORKING: bts_assert( _state_worker->state() == QueueHolderOrderState::WAITING_FOR_FIRST_ACK); _state_worker = &_working_state_worker; break; case QueueHolderOrderState::WAITING_FOR_CANCEL_ALL: bts_assert( _state_worker->state() == QueueHolderOrderState::WAITING_FOR_FIRST_ACK || _state_worker->state() == QueueHolderOrderState::WORKING); _state_worker = &_waiting_for_cancel_all_state_worker; break; case QueueHolderOrderState::END: bts_assert(_state_worker->state() != QueueHolderOrderState::END); _state_worker = &_end_state_worker; break; } _state_worker->on_transition(); _report_state(); LOG(OrderMan, Info, "QueueHolderOrder::_switch_state key:{} {}->{}", key(), s0, _state_int()); } api::orderman::OrderStatus QueueHolderOrder::_status(std::string &message) const { QueueHolderOrderState curr_state = _state_worker == nullptr ? QueueHolderOrderState::START : _state(); switch (curr_state) { case QueueHolderOrderState::START: case QueueHolderOrderState::WAITING_FOR_FIRST_ACK: case QueueHolderOrderState::WORKING: case QueueHolderOrderState::WAITING_FOR_CANCEL_ALL: return api::orderman::OrderStatus::ORDER_STATUS_WORKING; case QueueHolderOrderState::END: switch (_termination_reason) { case TerminationReason::NONE: { // this will happen if the order is // recovered or the init failed bts_assert(!_is_succ_inited || _is_recovered); if (!_is_succ_inited) { message = "Could not initialize order"; return api::orderman::OrderStatus::ORDER_STATUS_REJECTED_BY_SPARK; } else { message = "Recovered order"; // we could have done better here by [reserving ] return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; } } case TerminationReason::EXTERNAL_CANCEL: return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; case TerminationReason::FILLED: return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; case TerminationReason::UNEXPECTED_CHILD_CANCEL: message = "Child order cancelled"; return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; case TerminationReason::CHILD_ERROR: message = "Child order error"; return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; } } return api::orderman::OrderStatus::ORDER_STATUS_WORKING; } } // namespace orderman } // namespace bts