157 lines
6.0 KiB
C++
157 lines
6.0 KiB
C++
#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 <algorithm>
|
|
#include <sstream>
|
|
|
|
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
|