535 lines
19 KiB
C++
535 lines
19 KiB
C++
#include "TriggerOrder.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 "lib/orderman/orders/PreActivationOrderServices.h"
|
|
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
struct TriggerOrder::PImpl {
|
|
OrderServices *services;
|
|
api::orderman::OrderDefinition order_def;
|
|
double tick_size;
|
|
// true if timeout_exit is enabled
|
|
bool timeout_exit;
|
|
uint32_t timeout_msecs;
|
|
// true position cond exit is enabled
|
|
bool price_cond_exit;
|
|
api::orderman::OrderState state;
|
|
// child state copied directly from the
|
|
// child order udpate callback
|
|
api::orderman::OrderState child_state;
|
|
OrderBuilder order_builder;
|
|
ChildOrder child_order;
|
|
// true if child order has been placed once
|
|
bool order_placed;
|
|
Book book;
|
|
CancelMode cancel_mode;
|
|
// this tells that when the order is placed
|
|
// initially, if the trigger price above the
|
|
// market (trigger_condition's chosen market)
|
|
bool trigger_above_market;
|
|
// true is non 0 market corresponding
|
|
// to the trigger market is obs'ed once
|
|
bool market_observed_once;
|
|
bool is_recovered;
|
|
bool is_succ_inited;
|
|
bts::TimeStamp child_order_time;
|
|
PImpl()
|
|
: services(nullptr), order_def(), timeout_exit(false),
|
|
timeout_msecs(std::numeric_limits<uint32_t>::max()),
|
|
price_cond_exit(false), state(), child_state(), child_order(),
|
|
order_placed(false), book(), cancel_mode(CancelMode::none),
|
|
market_observed_once(false), is_recovered(false),
|
|
is_succ_inited(false) {}
|
|
};
|
|
|
|
TriggerOrder::TriggerOrder() : _state(State::START), me(new PImpl()) {}
|
|
TriggerOrder::~TriggerOrder() {}
|
|
const api::orderman::OrderDefinition &TriggerOrder::definition() const {
|
|
return me->order_def;
|
|
}
|
|
void TriggerOrder::on_init_new(const api::orderman::OrderDefinition &order_def,
|
|
const PreActivationOrderServices &pre_os) {
|
|
LOG(OrderMan, Info, "TriggerOrder::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_TRIGGER:
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
case State::STEADY:
|
|
case State::END:
|
|
std::ostringstream oss;
|
|
oss << "TriggerOrder::on_init_new key:" << key() << "state:" << _state;
|
|
bts_assert_msg(false, oss.str());
|
|
break;
|
|
}
|
|
}
|
|
void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord &rec,
|
|
const PreActivationOrderServices &pre_os) {
|
|
LOG(OrderMan, Info, "TriggerOrder::on_init_recovered key:{} state:{}", key(),
|
|
_state);
|
|
switch (_state) {
|
|
case State::START:
|
|
me->is_succ_inited = _on_init_new(rec.def(), pre_os);
|
|
// get the state from what was recovered (we will only use
|
|
// it for reporting)
|
|
me->state = rec.state();
|
|
// if it was not in a terminal state, we will call it cancelled
|
|
if (!SpreaderUtils::order_in_terminal_state(me->state.status()))
|
|
me->state.set_status(
|
|
api::orderman::OrderStatus::ORDER_STATUS_CANCELED);
|
|
me->is_recovered = true;
|
|
break;
|
|
case State::WAITING_FOR_TRIGGER:
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
case State::STEADY:
|
|
case State::END:
|
|
std::ostringstream oss;
|
|
oss << "TriggerOrder::on_init_recovered key:" << key()
|
|
<< "state:" << _state;
|
|
bts_assert_msg(false, oss.str());
|
|
break;
|
|
}
|
|
}
|
|
OrderOpResult TriggerOrder::on_activate(Price price, Quantity qty,
|
|
OrderServices &services) {
|
|
LOG(OrderMan, Info,
|
|
"TriggerOrder::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);
|
|
me->child_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); });
|
|
_switch_state(State::WAITING_FOR_TRIGGER);
|
|
}
|
|
break;
|
|
case State::WAITING_FOR_TRIGGER:
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
case State::STEADY:
|
|
case State::END: {
|
|
std::ostringstream oss;
|
|
oss << "TriggerOrder::on_activate key:" << key() << "state:" << _state;
|
|
bts_assert_msg(false, oss.str());
|
|
break;
|
|
}
|
|
}
|
|
return OrderOpResult{};
|
|
}
|
|
// order price, qty change
|
|
OrderOpResult TriggerOrder::on_update(Price price, Quantity qty) {
|
|
LOG(OrderMan, Info,
|
|
"TriggerOrder::on_update key:{} state:{} price:{} qty:{}", key(), _state,
|
|
price, qty);
|
|
switch (_state) {
|
|
case State::START:
|
|
me->state.set_price(price.value());
|
|
me->state.set_quantity(qty.value());
|
|
// cant report because does not have order_services yet
|
|
break;
|
|
case State::WAITING_FOR_TRIGGER:
|
|
me->state.set_price(price.value());
|
|
me->state.set_quantity(qty.value());
|
|
_report_state();
|
|
_analyze_trigger_and_shoot();
|
|
break;
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
case State::STEADY:
|
|
me->state.set_last_msg(
|
|
"Trigger order can not be modified after the trigger has been hit");
|
|
_report_state();
|
|
break;
|
|
case State::END:
|
|
break;
|
|
}
|
|
return OrderOpResult{};
|
|
}
|
|
OrderOpResult TriggerOrder::on_cancel() {
|
|
LOG(OrderMan, Info, "TriggerOrder::on_cancel key:{} state:{}", key(),
|
|
_state);
|
|
me->cancel_mode = CancelMode::external;
|
|
switch (_state) {
|
|
case State::START:
|
|
_switch_state(State::END);
|
|
break;
|
|
case State::WAITING_FOR_TRIGGER:
|
|
_switch_state(State::END);
|
|
break;
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
// we dont have a WAITING_FOR_ACK_CANCELLED
|
|
// (like the Quoter), so this message is
|
|
// rejected and reported
|
|
me->state.set_last_msg("Order is in flight");
|
|
_report_state();
|
|
break;
|
|
case State::STEADY:
|
|
_cancel_order(CancelMode::external);
|
|
break;
|
|
case State::END:
|
|
break;
|
|
}
|
|
return OrderOpResult{};
|
|
}
|
|
void TriggerOrder::_on_book_update(const BookUpdateEvent &b_event) {
|
|
switch (_state) {
|
|
case State::START:
|
|
break;
|
|
case State::WAITING_FOR_TRIGGER:
|
|
if (b_event.key().value() == me->order_def.security_key()) {
|
|
me->book = b_event.book;
|
|
_observe_market_once();
|
|
_analyze_trigger_and_shoot();
|
|
}
|
|
break;
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
break;
|
|
case State::STEADY:
|
|
if (b_event.key().value() == me->order_def.security_key()) {
|
|
if (me->price_cond_exit) {
|
|
me->book = b_event.book;
|
|
_analyze_trigger_and_cancel();
|
|
}
|
|
}
|
|
case State::END:
|
|
break;
|
|
}
|
|
}
|
|
void TriggerOrder::_on_child_order_update(const OrderStateUpdateEvent &o_ev) {
|
|
if (o_ev.key == me->child_order.key()) {
|
|
auto ev_state = o_ev.rebuild_state();
|
|
me->child_state = ev_state;
|
|
switch (_state) {
|
|
case State::START:
|
|
case State::WAITING_FOR_TRIGGER:
|
|
bts_assert(false);
|
|
break;
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
if (SpreaderUtils::order_acknowledged(o_ev.status)) {
|
|
if (SpreaderUtils::order_in_terminal_state(o_ev.status))
|
|
_switch_state(State::END);
|
|
else
|
|
_switch_state(State::STEADY);
|
|
}
|
|
break;
|
|
case State::STEADY:
|
|
if (SpreaderUtils::order_in_terminal_state(ev_state.status()))
|
|
_switch_state(State::END);
|
|
break;
|
|
case State::END:
|
|
break;
|
|
}
|
|
_report_state();
|
|
}
|
|
}
|
|
void TriggerOrder::_on_time(const bts::mercury::TimerEvent &) {
|
|
switch (_state) {
|
|
case State::START:
|
|
case State::WAITING_FOR_TRIGGER:
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
break;
|
|
case State::STEADY: {
|
|
if (me->timeout_exit)
|
|
_analyze_trigger_and_cancel();
|
|
break;
|
|
}
|
|
case State::END:
|
|
break;
|
|
}
|
|
}
|
|
bool TriggerOrder::_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_trigger()) {
|
|
LOG(OrderMan, Error,
|
|
"TriggerOrder::_on_init_new key:{} state:{} "
|
|
"OrderDefinition does not have TriggerOrderDefinition",
|
|
key(), _state);
|
|
me->state.set_last_msg("Trigger Order not properly formed");
|
|
return false;
|
|
}
|
|
if (pre_os.sec_db.resolve(SecurityKey(order_def.security_key())) ==
|
|
nullptr) {
|
|
LOG(OrderMan, Error,
|
|
"TriggerOrder::_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 auto &trigger_order_def = order_def.custom_def().trigger();
|
|
if (pre_os.sec_db.resolve(SecurityKey(
|
|
trigger_order_def.trigger_action().security_id())) == nullptr) {
|
|
LOG(OrderMan, Error,
|
|
"TriggerOrder::_on_init_new key:{} state:{} "
|
|
"Could not resolve child key sec_key:{}",
|
|
key(), _state, trigger_order_def.trigger_action().security_id());
|
|
me->state.set_last_msg("Could not resolve Trigger Order child security");
|
|
return false;
|
|
}
|
|
if (!trigger_order_def.trigger_action().has_payup() &&
|
|
bts::os::is_nan(trigger_order_def.trigger_action().price())) {
|
|
LOG(OrderMan, Error,
|
|
"TriggerOrder::_on_init_new key:{} state:{} "
|
|
"illegal child order price",
|
|
key(), _state);
|
|
me->state.set_last_msg("Illegal Child Order price");
|
|
return false;
|
|
}
|
|
me->timeout_exit = trigger_order_def.has_exit_condition() &&
|
|
trigger_order_def.exit_condition().timeout_enabled();
|
|
me->timeout_msecs =
|
|
trigger_order_def.has_exit_condition()
|
|
? 1000.0 * trigger_order_def.exit_condition().timeout_seconds()
|
|
: std::numeric_limits<uint32_t>::max();
|
|
me->price_cond_exit =
|
|
trigger_order_def.has_exit_condition() &&
|
|
trigger_order_def.exit_condition().conditional_cancel();
|
|
|
|
api::orderman::OrderDefinition child_order_def = order_def;
|
|
child_order_def.set_security_key(
|
|
trigger_order_def.trigger_action().security_id());
|
|
child_order_def.mutable_custom_def()->CopyFrom(trigger_order_def.child());
|
|
me->order_builder = OrderBuilder(key(), child_order_def, pre_os.order_factory);
|
|
const auto *sec_ptr =
|
|
pre_os.sec_db.resolve(SecurityKey(order_def.security_key()));
|
|
me->tick_size = std::min(sec_ptr->contract_spec().low_tick(),
|
|
sec_ptr->contract_spec().high_tick());
|
|
LOG(OrderMan, Info,
|
|
"TriggerOrder::_on_init_new key:{} state:{} "
|
|
"trigger_price_type:{} child_order_price:{}",
|
|
key(), _state, trigger_order_def.trigger_condition().price_type(),
|
|
trigger_order_def.trigger_action().price());
|
|
|
|
return true;
|
|
}
|
|
void TriggerOrder::_report_state() {
|
|
if (_activated()) {
|
|
_compute_state();
|
|
me->services->report_state(me->state);
|
|
}
|
|
}
|
|
void TriggerOrder::_switch_state(State new_state) {
|
|
switch (new_state) {
|
|
case State::START:
|
|
break;
|
|
case State::WAITING_FOR_TRIGGER:
|
|
bts_assert(_state == State::START);
|
|
break;
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
bts_assert(_state == State::WAITING_FOR_TRIGGER);
|
|
break;
|
|
case State::STEADY:
|
|
bts_assert(_state == State::WAITING_FOR_FIRST_ACK);
|
|
break;
|
|
case State::END:
|
|
bts_assert(_state != State::END);
|
|
break;
|
|
}
|
|
LOG(OrderMan, Info, "TriggerOrder::_report_state key:{} {}->{}", key(),
|
|
_state, new_state);
|
|
_state = new_state;
|
|
_report_state();
|
|
}
|
|
void TriggerOrder::_analyze_trigger_and_shoot() {
|
|
if (me->market_observed_once) {
|
|
double trigger_price = _trigger_price();
|
|
const md::PriceSize *obs_md = _observed_market();
|
|
if (_trigger_met(obs_md, trigger_price, me->tick_size,
|
|
me->trigger_above_market)) {
|
|
me->child_order_time = bts::Timer::now();
|
|
me->order_placed = true;
|
|
LOG(OrderMan, Info,
|
|
"TriggerOrder::_analyze_trigger_and_shoot"
|
|
"key:{} state:{} "
|
|
"trigger_above_md:{} trigger_price:{} md:{} "
|
|
"order_price:{} order_qty:{}",
|
|
key(), _state, me->trigger_above_market, trigger_price,
|
|
obs_md->price(), _child_order_price(), me->state.quantity());
|
|
me->child_order.activate(Price(_child_order_price()),
|
|
Quantity(me->state.quantity()));
|
|
_switch_state(State::WAITING_FOR_FIRST_ACK);
|
|
}
|
|
}
|
|
}
|
|
void TriggerOrder::_analyze_trigger_and_cancel() {
|
|
if (me->timeout_exit) {
|
|
int64_t time_diff = ms_diff(bts::Timer::now(), me->child_order_time);
|
|
if (time_diff > me->timeout_msecs) {
|
|
LOG(OrderMan, Info,
|
|
"TriggerOrder::_analyze_trigger_and_cancel "
|
|
"key:{} state:{} msecs:{} "
|
|
"time out, cancelling order",
|
|
key(), _state, time_diff);
|
|
_cancel_order(CancelMode::trigger);
|
|
return;
|
|
}
|
|
}
|
|
if (me->price_cond_exit) {
|
|
double trigger_price = _trigger_price();
|
|
const md::PriceSize *obs_md = _observed_market();
|
|
if (!_trigger_met(obs_md, trigger_price, me->tick_size,
|
|
me->trigger_above_market)) {
|
|
LOG(OrderMan, Info,
|
|
"TriggerOrder::_analyze_trigger_and_cancel"
|
|
"key:{} state:{} "
|
|
"price condition untrue, cancelling order"
|
|
"trigger_above_md:{} trigger_price:{} md:{} ",
|
|
key(), _state, me->trigger_above_market, trigger_price,
|
|
obs_md->price());
|
|
_cancel_order(CancelMode::trigger);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
api::orderman::OrderStatus TriggerOrder::_status() const {
|
|
switch (_state) {
|
|
// will only be called once the order
|
|
// has been activated
|
|
case State::START:
|
|
case State::WAITING_FOR_TRIGGER:
|
|
case State::WAITING_FOR_FIRST_ACK:
|
|
case State::STEADY:
|
|
return api::orderman::OrderStatus::ORDER_STATUS_WORKING;
|
|
case State::END:
|
|
if (!me->is_succ_inited)
|
|
return api::orderman::OrderStatus::ORDER_STATUS_ERROR;
|
|
else {
|
|
if (me->order_placed) {
|
|
if (!SpreaderUtils::order_in_terminal_state(
|
|
me->child_state.status()))
|
|
return api::orderman::OrderStatus::ORDER_STATUS_WORKING;
|
|
else {
|
|
if (SpreaderUtils::order_in_error_state(
|
|
me->child_state.status()))
|
|
return api::orderman::OrderStatus::ORDER_STATUS_ERROR;
|
|
else if (SpreaderUtils::order_in_completed_state(
|
|
me->child_state.status()))
|
|
return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED;
|
|
else if (SpreaderUtils::order_in_cancelled_state(
|
|
me->child_state.status())) {
|
|
switch (me->cancel_mode) {
|
|
case CancelMode::none: // this means an unscolicted child cxl
|
|
case CancelMode::external:
|
|
return api::orderman::OrderStatus::ORDER_STATUS_CANCELED;
|
|
case CancelMode::trigger:
|
|
return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED;
|
|
}
|
|
}
|
|
}
|
|
} else
|
|
return api::orderman::OrderStatus::ORDER_STATUS_CANCELED;
|
|
}
|
|
}
|
|
bts_assert(false);
|
|
return api::orderman::OrderStatus::ORDER_STATUS_INACTIVE;
|
|
}
|
|
void TriggerOrder::_compute_state() {
|
|
if (!me->is_recovered) {
|
|
me->state.set_status(_status());
|
|
me->state.set_filled_quantity(me->child_state.filled_quantity());
|
|
me->state.set_last_price(me->child_state.last_price());
|
|
me->state.set_avg_price(me->child_state.avg_price());
|
|
if (_state == State::STEADY)
|
|
me->state.set_display_status(bts::api::orderman::OrderState::HIDDEN);
|
|
else
|
|
me->state.set_display_status(bts::api::orderman::OrderState::VISIBLE);
|
|
}
|
|
}
|
|
void TriggerOrder::_observe_market_once() {
|
|
if (!me->market_observed_once) {
|
|
const md::PriceSize *obs_md = _observed_market();
|
|
if (obs_md != nullptr && obs_md->size() > 0) {
|
|
me->market_observed_once = true;
|
|
me->trigger_above_market = _trigger_price() >= obs_md->price();
|
|
LOG(OrderMan, Info,
|
|
"TriggerOrder::_observe_market_once "
|
|
"key:{} state:{} "
|
|
"md_p:{} md_q:{} trigger_above_md:{}",
|
|
key(), _state, obs_md->price(), obs_md->size(),
|
|
me->trigger_above_market);
|
|
}
|
|
}
|
|
}
|
|
const md::PriceSize *TriggerOrder::_observed_market() const {
|
|
if (me->order_def.custom_def().trigger().trigger_condition().price_type() ==
|
|
api::orderman::TriggerPriceType::BID) {
|
|
const auto &rv = me->book.bid()[0];
|
|
return &rv;
|
|
} else if (me->order_def.custom_def()
|
|
.trigger()
|
|
.trigger_condition()
|
|
.price_type() == api::orderman::TriggerPriceType::ASK) {
|
|
const auto &rv = me->book.ask()[0];
|
|
return &rv;
|
|
} else {
|
|
bts_assert(false);
|
|
return nullptr;
|
|
}
|
|
}
|
|
double TriggerOrder::_trigger_price() const { return me->state.price(); }
|
|
double TriggerOrder::_child_order_price() const {
|
|
const auto &trigger_action =
|
|
me->order_def.custom_def().trigger().trigger_action();
|
|
double rv = bts::os::nan();
|
|
if (trigger_action.has_payup()) {
|
|
double offset = trigger_action.payup().payup_ticks() * me->tick_size;
|
|
if (me->order_def.side() == api::Side::SIDE_BUY)
|
|
rv = _trigger_price() + offset;
|
|
else
|
|
rv = _trigger_price() - offset;
|
|
} else
|
|
rv = trigger_action.price();
|
|
rv = bts::securities::raw_round_to_quote_price(rv, me->tick_size,
|
|
me->order_def.side());
|
|
return rv;
|
|
}
|
|
void TriggerOrder::_cancel_order(CancelMode cancel_mode) {
|
|
me->cancel_mode = cancel_mode;
|
|
me->child_order.cancel();
|
|
LOG(OrderMan, Info, "TriggerOrder::_cancel_order key:{} state:{} mode:{}",
|
|
key(), _state, cancel_mode);
|
|
_switch_state(State::END);
|
|
}
|
|
bool TriggerOrder::_activated() const { return me->services != nullptr; }
|
|
bool TriggerOrder::_gr_than_eq(double p1, double p2, double tick_size) {
|
|
return bts::securities::test_price_equality(p1, p2, tick_size) || p1 >= p2;
|
|
}
|
|
bool TriggerOrder::_trigger_met(const md::PriceSize *obs_md, double trpr,
|
|
double tick_size, bool trigger_above_md) {
|
|
if (obs_md != nullptr)
|
|
return (trigger_above_md &&
|
|
_gr_than_eq(obs_md->price(), trpr, tick_size)) ||
|
|
(!trigger_above_md &&
|
|
_gr_than_eq(trpr, obs_md->price(), tick_size));
|
|
return false;
|
|
}
|
|
} // namespace orderman
|
|
} // namespace bts
|