Files
spark/src/lib/orderman/orders/TriggerOrder.cpp
T
2018-08-29 14:16:48 -04:00

537 lines
20 KiB
C++

#include "TriggerOrder.h"
#include "lib/logging/logging.h"
#include "lib/utils/PBUtils.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/domain_model/Security.h"
#include "lib/os/os.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;
}
}
void TriggerOrder::on_activate(Price price,
Quantity qty,
OrderServices& services,
TickToTradeCorID){
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.child_updates.sub(key(),
[this](const OrderStateUpdateEvent& os)
{ this->_on_child_order_update (os);});
services.book_updates.sub(SecurityKey(me->order_def.security_key()),
[this](const BookUpdateEvent& bk_event)
{ this->_on_book_update (bk_event);});
services.time_change.sub([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;
}
}
}
// order price, qty change
void TriggerOrder::on_update(Price price,
Quantity qty,
TickToTradeCorID){
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;
}
}
void TriggerOrder::on_crack(TickToTradeCorID){
// not supported
}
void TriggerOrder::on_cancel(TickToTradeCorID){
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;
}
}
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()){
me->child_state=o_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.state.status())){
if(SpreaderUtils::order_in_terminal_state(o_ev.state.status()))
_switch_state(State::END);
else
_switch_state(State::STEADY);
}
break;
case State::STEADY:
if(SpreaderUtils::order_in_terminal_state(o_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);
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;
}
}}