167 lines
6.4 KiB
C++
167 lines
6.4 KiB
C++
#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 <algorithm>
|
|
#include <sstream>
|
|
#include "lib/os/os.h"
|
|
|
|
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) {
|
|
_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
|