337 lines
14 KiB
C++
337 lines
14 KiB
C++
#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<SpreaderLegData>(), 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;}
|
|
}} |