#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 #include 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::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::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; } }}