Files
spark/src/lib/orderman/orders/queue_holder/QueueHolderOrder.cpp
T

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