#include "SpreaderOrder.h" #include "lib/logging/logging.h" #include "lib/utils/PBUtils.h" #include "server/sparkd/spreader/SpreaderChildOrderState.h" #include "server/sparkd/orderman/spreader_orders/SpreaderOrderState.h" #include "server/sparkd/securities/SecurityDB.h" #include "server/sparkd/spreader/SpreaderUtils.h" #include "server/sparkd/spreader/LegPropertyData.h" #include "server/sparkd/spreader/SpreaderLegData.h" #include "server/sparkd/spreader/SpreaderBookkeepingData.h" namespace bts { namespace orderman { SpreaderOrder::SpreaderOrder(securities::ISecurityDB &db, NativeOrderFactory &f, const api::orderman::OrderState& os) : SpreaderOrderBase(db, f, os), _cancel_timeout (5000),// TODO:get it from config _active(false), _real_orders (!bts::utils::internal::is_unittest_environment()), _create_order_request (api::orderman::CreateOrderRequest()), _state_worker(nullptr) { LOG(OrderMan, Diag, "SpreaderOrder.cons recovered from disk, key: {}", os.order_key() ); } SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db, NativeOrderFactory& f, OrderKey k, const api::orderman::CreateOrderRequest& cor) : SpreaderOrderBase(db, f, k, cor), _cancel_timeout (5000),// TODO:get it from config _active (true), _real_orders (!bts::utils::internal::is_unittest_environment()), _create_order_request (cor), _bookkeeping_data (SpreaderBookkeepingData (std::vector(), Price(cor.spreader().price()), Quantity(cor.spreader().quantity()))), _state_worker(nullptr) { LOG(OrderMan, Diag, "SpreaderOrder.cons request: {} key: {}", utils::pb::to_string(cor), k.value()); bts_assert(cor.has_spreader()); bts_assert(cor.spreader().security().has_synthetic()); _transform_to_START (); } SpreaderOrder::~SpreaderOrder () {} void SpreaderOrder::init() { if (!_active) return; LOG(OrderMan, Diag, "SpreaderOrder.init key: {}", key().value()); _state_worker->init(); } void SpreaderOrder::on_connect() { if (!_active) return; LOG(OrderMan, Diag, "SpreaderOrder.on_connect key: {}", key().value()); _state_worker->on_connect (); } void SpreaderOrder::on_disconnect() { if (!_active) return; LOG(OrderMan, Diag, "SpreaderOrder.on_disconnect key: {}", key().value()); _state_worker->on_disconnect(); } void SpreaderOrder::on_update(const api::orderman::UpdateSpreaderOrder& u) { if (!_active) return; LOG(OrderMan, Diag, "SpreaderOrder.on_update key: {}", key().value()); _state_worker->on_update(u); } void SpreaderOrder::on_cancel(const api::orderman::CancelSpreaderOrder& c) { if (!_active) return; LOG(OrderMan, Diag, "SpreaderOrder.on_cancel key: {}", key().value()); _state_worker->on_cancel(c); } void SpreaderOrder::on_book(TickToTradeCorID cid, Book const& book) { if (!_active) return; LOG(Latency, Info, "on_book {} {}", cid, utils::TimeStamp::now().to_uint64()); _state_worker->on_book (cid, book); } void SpreaderOrder::on_time(const bts::TimeStamp& ts) { _curr_timestamp = ts; if (!_active) return; _state_worker->on_time (ts); } void SpreaderOrder::on_child_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const *error_msg) { if (!_active) return; static std::string empty; LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} status: {} filled_qty: {} avg_price: {} reject_msg: {}", order_key.value(), status, filled_quantity.value(), average_price.value(), error_msg == nullptr ? empty : *error_msg); SpreaderLegData* leg_data_ptr = _bookkeeping_data.find_leg_from_quoter_orderkey(order_key); if (leg_data_ptr != nullptr) { SpreaderLegData& leg_data = *leg_data_ptr; LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} is a quoting order, forwarding", order_key.value()); if (error_msg != nullptr) _state_worker->on_quoter_order_error (leg_data, status, filled_quantity, average_price, error_msg); else { if (filled_quantity.value() != 0) _state_worker->on_quoter_order_fill (leg_data, status, filled_quantity, average_price); else _state_worker->on_quoter_order_status_update (leg_data, status); } } else { // should be a hedge order then SpreaderHedgerData* hedger_data = _bookkeeping_data.find_hedger_from_orderkey(order_key); if (hedger_data != nullptr) { LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} is a hedging order, forwarding", order_key.value()); if (error_msg != nullptr) _state_worker->on_hedger_order_error (order_key, status, filled_quantity, average_price, error_msg); else _state_worker->on_hedger_order_update (order_key, status, filled_quantity, average_price); } else bts_assert_msg (false, "This order was not initiated in this spreader"); } _state_worker->on_check_termination (); } void SpreaderOrder::on_external_error(const std::string& reason) { if (!_active) return; LOG(OrderMan,Warn, "on_external_error SpreaderOrder. msg: {}", reason); _state_worker->on_external_error (reason); } const orderman::Book& SpreaderOrder::get_book(size_t leg_index) const { return _bookkeeping_data.get_leg_data(leg_index).book(); } const LegPropertyData& SpreaderOrder::get_leg_data(size_t leg_index) const { return _bookkeeping_data.get_leg_data(leg_index).leg_property_data(); } bts::orderman::SpreaderOrderBase::ChildOrder SpreaderOrder::setup_new_quoter_order (const LegPropertyData& leg_property_data) { bts::orderman::SpreaderOrderBase::ChildOrder rv = _get_new_order (leg_property_data, true); SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data (leg_property_data.leg_index()); leg_data.order_update_message().init (rv.order_key()); return rv; } void SpreaderOrder::place_order (SpreaderOrderBase::ChildOrder& child_order, TickToTradeCorID cid, Price price, Quantity quantity) { if (_real_orders) child_order.create(cid, price, quantity); } void SpreaderOrder::modify_order (SpreaderOrderBase::ChildOrder& child_order, TickToTradeCorID cid, Price price, Quantity quantity) { if (_real_orders) child_order.update(cid, price, quantity); } void SpreaderOrder::cancel_order (SpreaderOrderBase::ChildOrder& child_order) { if (_real_orders) child_order.cancel(); } void SpreaderOrder::_transform_to_START() { bts_assert (_state_worker == nullptr); _switch_state (&_start_state_worker); _report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderOrder::_transform_to_WAITING_FOR_FIRST_CONNECTION() { bts_assert(_state_worker->state() == SpreaderState::START); _switch_state(&_waiting_for_first_conn_state_worker); _report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderOrder::_transform_to_WORKING() { bts_assert(_state_worker->state() == SpreaderState::WAITING_FOR_FIRST_CONNECT); _switch_state(&_working_state_worker); _report_state (api::orderman::OrderStatus::OS_NEW); } void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL() { bts_assert(_state_worker->state() == SpreaderState::WORKING); _switch_state(&_waiting_for_cancel_all_state_worker); _report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); } void SpreaderOrder::_transform_to_END(std::string* m) { bts_assert(_state_worker->state() != SpreaderState::END); _switch_state(&_end_state_worker); _report_state (api::orderman::OrderStatus::OS_DONE, m); } void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) { for (size_t q_idx = 0; q_idx < _bookkeeping_data.n_legs(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (cancel_quotes) { if (leg_data.leg_property_data().is_active_quoting()) leg_data.quoter()->cancel_order(); } if (cancel_hedges) for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) { SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); hedger_data.hedger().cancel_hedge(); } } } bool SpreaderOrder::_all_quoter_orders_in_terminal_state() { for (size_t q_idx = 0; q_idx < _bookkeeping_data.n_legs(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) if (!leg_data.quoter()->is_terminal_state()) return false; } return true; } // same as _all_quoter_orders_in_terminal_state, for hedgers bool SpreaderOrder::_all_hedger_orders_in_terminal_state() { for (size_t q_idx = 0; q_idx < _bookkeeping_data.n_legs(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) { SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); if (!hedger_data.hedger().is_terminal_state()) return false; } } return true; } void SpreaderOrder::_terminate_quoters () { for (size_t q_idx = 0; q_idx < _bookkeeping_data.n_legs(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); leg_data.quoter()->terminate(); } } void SpreaderOrder::_terminate_hedgers () { for (size_t q_idx = 0; q_idx < _bookkeeping_data.n_legs(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) { SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); hedger_data.hedger().terminate (); } } } bool SpreaderOrder::_quoters_can_accept_modification () { for (size_t q_idx = 0; q_idx < _bookkeeping_data.n_legs(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) if (!leg_data.quoter()->accept_modifications()) return false; } return true; } void SpreaderOrder::_send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t hedge_leg_index) { Price hedge_price; Quantity hedge_quantity; SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data (hedge_leg_index); _compute_hedge_price_quantity (filled_leg_index, filled_price, filled_quantity, hedge_leg_index, hedge_price, hedge_quantity); bts::orderman::SpreaderOrderBase::ChildOrder new_hedge_order = _get_new_order (leg_data.leg_property_data(), false); SpreaderHedgerData& hedger_data = leg_data.add_new_hedger (*this, new_hedge_order, hedge_price, hedge_quantity,leg_data.leg_property_data().trading_side()); hedger_data.hedger().init (); } void SpreaderOrder::_compute_hedge_price_quantity(size_t filled_leg_index, Price fill_price, Quantity fill_quantity, size_t hedge_leg_index, Price& hedge_price, Quantity& hedge_quantity) { SpreaderLegData& filled_leg_data = _bookkeeping_data.get_leg_data(filled_leg_index); SpreaderLegData& hedged_leg_data = _bookkeeping_data.get_leg_data(hedge_leg_index); if (_bookkeeping_data.n_legs() == 2) { SpreaderUtils::compute_hedge_price_size_2_legs (_bookkeeping_data.price(), filled_leg_data.leg_property_data(), fill_price, fill_quantity, hedged_leg_data.leg_property_data(), hedge_price, hedge_quantity); } else { Price driver_price = hedged_leg_data.quoter()->driver_price(hedge_leg_index); SpreaderUtils::compute_hedge_price_size_n_legs (filled_leg_data.leg_property_data(), fill_price, fill_quantity, driver_price, hedged_leg_data.leg_property_data(), hedge_price, hedge_quantity); } } void SpreaderOrder::_report_state (api::orderman::OrderStatus order_status, std::string* msg) { if (_real_orders) report_state_change(SpreaderOrderState{ order_status, _bookkeeping_data.price(), _bookkeeping_data.quantity(), msg }); } void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state) { LOG(OrderMan, Info, "SpreaderOrder::_switch_state key: {}, {} -> {} ", key().value(), (_state_worker == nullptr ? "NULL" : _state_worker->state_text()), new_state->state_text()); _state_worker = new_state; _state_worker->build_once (this); } bts::orderman::SpreaderOrderBase::ChildOrder SpreaderOrder::_get_new_order (const LegPropertyData& leg_property_data, bool is_quote_order) { bts::SecurityKey sec_key = bts::SecurityKey (leg_property_data.security_key()); api::Security const* db_sec = _db().resolve (sec_key); api::orderman::ChildOrderKind order_type = is_quote_order ? api::orderman::ChildOrderKind::COK_SPREADER_QUOTING : api::orderman::ChildOrderKind::COK_SPREADER_HEDGING; bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(*db_sec, leg_property_data.trading_side(), order_type); return child_factory(); } /*******************************************************************************/ /***************************Functions to Help Testing****************************/ SpreaderState SpreaderOrder::test_only_func_spreader_state() {return _state_worker->state();} SpreaderLegData& SpreaderOrder::test_only_func_spreader_leg_data (size_t index) { SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data (index); return leg_data; } SpreaderBookkeepingData& SpreaderOrder::test_only_func_spreader_full_data() {return _bookkeeping_data;} }}