Files
spark/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp
T
2017-12-27 18:38:49 -05:00

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;}
}}