Spark-267 better logging

This commit is contained in:
Taha Afzal committed 2017-11-10 17:50:35 -05:00
1 parent 5998b599be
commit 7bd1302f22
6 files changed
+78 -91

No files matched your search

@@ -138,31 +138,31 @@ void SpreaderOrder::_transform_to_START()
{
bts_assert (_state_worker == nullptr);
_switch_state (&_start_state_worker);
report_state (api::orderman::OrderStatus::OS_PENDING_NEW);
_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);
_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);
_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);
_report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL);
}
void SpreaderOrder::_transform_to_END()
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);
_report_state (api::orderman::OrderStatus::OS_DONE, m);
}
void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges)
{
@@ -259,22 +259,13 @@ void SpreaderOrder::_compute_hedge_price_quantity(size_t,
Price&, Quantity&)
{
}
void SpreaderOrder::report_state (api::orderman::OrderStatus order_status)
void SpreaderOrder::_report_state (api::orderman::OrderStatus order_status, std::string* m)
{
report_state_change(SpreaderOrderState{
order_status,
_bookkeeping_data.price(),
_bookkeeping_data.quantity(),
nullptr
});
}
void SpreaderOrder::report_state (api::orderman::OrderStatus order_status, std::string& message)
{
report_state_change(SpreaderOrderState{
order_status,
_bookkeeping_data.price(),
_bookkeeping_data.quantity(),
message.empty() ? nullptr : &message
m
});
}
void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state)
@@ -283,8 +274,6 @@ void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state)
_state_worker = new_state;
_state_worker->build_once (this);
}
SpreaderBookkeepingData& SpreaderOrder::bookkeeping_data () {return _bookkeeping_data;}
/*******************************************************************************/
/***************************Functions to Help Testing****************************/
SpreaderState SpreaderOrder::test_only_func_state() {return _state_worker->state();}
@@ -77,7 +77,7 @@ private:
void _transform_to_WAITING_FOR_FIRST_CONNECTION();
void _transform_to_WORKING();
void _transform_to_WAITING_FOR_CANCEL_ALL();
void _transform_to_END();
void _transform_to_END(std::string* m = nullptr);
// this cancels the quoters and hedger orders (through them);
// can cancel the quotes or the hedges or both
void _cancel_orders(bool cancel_quotes, bool cancel_hedges);
@@ -86,7 +86,10 @@ private:
bool _all_quoter_orders_in_terminal_state();
// same as _all_quoter_orders_in_terminal_state, for hedgers
bool _all_hedger_orders_in_terminal_state();
// sends all the quoters immedatly to the their terminal state
// abandoning everything they were doing
void _terminate_quoters ();
// same as the above for hedgers
void _terminate_hedgers();
bool _quoters_can_accept_modification();
void _send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_to_hedge_index);
@@ -94,11 +97,10 @@ private:
Price filled_price, Quantity filled_quantity,
size_t hedged_index,
Price& hedge_price, Quantity& hedge_quantity);
void report_state (api::orderman::OrderStatus order_status);
void report_state (api::orderman::OrderStatus order_status, std::string& message);
SpreaderBookkeepingData& bookkeeping_data ();
void _report_state (api::orderman::OrderStatus order_status, std::string* message = nullptr);
void _switch_state (ISpreaderStateWorker* new_state);
private:
std::string _msg;
const bool _active;
const api::orderman::CreateOrderRequest _create_order_request;
SpreaderBookkeepingData _bookkeeping_data;
@@ -13,9 +13,7 @@ void SpreaderEndStateWorker::build_once (SpreaderOrder* spreader)
}
void SpreaderEndStateWorker::init ()
{
// all error-free order status updates in this state (and the next)
// are OS_PENDING_NEW. order goes to OS_NEW once it is WORKING
bts_assert_msg(false, "Illegal Spreader operation {END,on_connect}");
bts_assert_msg (false, "SpreaderEndStateWorker::init is an illegal operation");
}
void SpreaderEndStateWorker::on_connect()
{
@@ -43,12 +41,10 @@ void SpreaderEndStateWorker::on_hedger_order_error(OrderKey, api::orderman::Orde
{}
void SpreaderEndStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price)
{}
void SpreaderEndStateWorker::on_external_error(std::string const& err_msg)
void SpreaderEndStateWorker::on_external_error(std::string const&)
{
LOG(OrderMan, Warn, "SpreaderEndStateWorker.on_external_error err_msg:{}", err_msg);
}
void SpreaderEndStateWorker::on_check_termination ()
{
}
}}
@@ -13,26 +13,23 @@ void SpreaderWaitingForCancelAllStateWorker::build_once (SpreaderOrder* spreader
}
void SpreaderWaitingForCancelAllStateWorker::init ()
{
bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_CANCEL_ALL,init}");
bts_assert_msg (false, "SpreaderWaitingForCancelAllStateWorker::init is an illegal operation");
}
void SpreaderWaitingForCancelAllStateWorker::on_connect()
{
bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_CANCEL_ALL,on_connect}");
bts_assert_msg (false, "SpreaderWaitingForCancelAllStateWorker::on_connect is an illegal operation");
}
void SpreaderWaitingForCancelAllStateWorker::on_disconnect()
{
_spreader->_terminate_quoters();
_spreader->_terminate_hedgers ();
_spreader->report_state (api::orderman::OrderStatus::OS_STOPPED);
_spreader->_transform_to_END ();
}
void SpreaderWaitingForCancelAllStateWorker::on_update(const api::orderman::UpdateSpreaderOrder&)
{
_spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK);
}
void SpreaderWaitingForCancelAllStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&)
{
// nothing already waiting for cancel
}
void SpreaderWaitingForCancelAllStateWorker::on_book(TickToTradeCorID, Book const&)
{
@@ -41,9 +38,10 @@ void SpreaderWaitingForCancelAllStateWorker::on_time(const TimeStamp&)
{
// TODO, if enough time has elapsed then tranform to end
}
void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*)
void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg)
{
// on_error results in cancelling, however this is already waiting for cancel here
leg_data.order_update_message().update (status, filled_quantity, average_price, err_msg);
leg_data.quoter().update_order_status (leg_data.order_update_message());
}
void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status,
Quantity filled_quantity, Price average_price)
@@ -55,13 +53,23 @@ void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_status_update(bts::
{
leg_data.order_update_message().update (status);
}
void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*)
void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg)
{
// on_error results in cancelling, however this is already waiting for cancel here
SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key);
if (hedger_data != nullptr)
{
hedger_data->order_update_message().update(status, filled_quantity, average_price, err_msg);
hedger_data->hedger().on_order_update(hedger_data->order_update_message());
}
}
void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price)
void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price)
{
// TODO, update hedger
SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key);
if (hedger_data != nullptr)
{
hedger_data->order_update_message().update(status, filled_quantity, average_price, nullptr);
hedger_data->hedger().on_order_update(hedger_data->order_update_message());
}
}
void SpreaderWaitingForCancelAllStateWorker::on_external_error(std::string const&)
{
@@ -69,9 +77,6 @@ void SpreaderWaitingForCancelAllStateWorker::on_external_error(std::string const
void SpreaderWaitingForCancelAllStateWorker::on_check_termination()
{
if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state())
{
_spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); // TODO, figure out if it was filled or cxl'ed
_spreader->_transform_to_END ();
}
}
}}
@@ -35,8 +35,7 @@ void SpreaderWaitingForFirstConnStateWorker::on_connect()
// if securities can not be resolved, the order is terminated
LOG(OrderMan, Diag, "SpreaderWaitingForFirstConnStateWorker.on_connect key: {} , could not resolve securities", _spreader->key().value());
std::string msg = "Could not resolve securities";
_spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg);
_spreader->_transform_to_END ();
_spreader->_transform_to_END (&msg);
}
}
void SpreaderWaitingForFirstConnStateWorker::on_disconnect()
@@ -49,7 +48,8 @@ void SpreaderWaitingForFirstConnStateWorker::on_update(const api::orderman::Upda
}
void SpreaderWaitingForFirstConnStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&)
{
_spreader->_transform_to_END();
std::string msg = "Order cancelled";
_spreader->_transform_to_END(&msg);
}
void SpreaderWaitingForFirstConnStateWorker::on_book(TickToTradeCorID, Book const&)
{
@@ -78,9 +78,10 @@ void SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update(OrderKey, ap
{
bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update is an illegal operation");
}
void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const&)
void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const& err_msg)
{
_spreader->_transform_to_END ();
std::string msg = "Error message: " + err_msg;
_spreader->_transform_to_END (&msg);
}
void SpreaderWaitingForFirstConnStateWorker::on_check_termination()
{}
@@ -13,47 +13,42 @@ void SpreaderWorkingStateWorker::build_once (SpreaderOrder* spreader)
}
void SpreaderWorkingStateWorker::init ()
{
bts_assert_msg(false, "Illegal Spreader operation {WORKING,init}");
bts_assert_msg (false, "SpreaderWorkingStateWorker::init is an illegal operation");
}
void SpreaderWorkingStateWorker::on_connect()
{
bts_assert_msg(false, "Illegal Spreader operation {WORKING,on_connect}");
bts_assert_msg (false, "SpreaderWorkingStateWorker::on_connect is an illegal operation");
}
void SpreaderWorkingStateWorker::on_disconnect()
{
_spreader->_terminate_quoters ();
_spreader->_terminate_hedgers();
_spreader->report_state (api::orderman::OrderStatus::OS_CANCELED);
_spreader->_transform_to_END ();
_spreader->_msg = "disconnected";
_spreader->_transform_to_END (&(_spreader->_msg));
}
void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update)
void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& u)
{
if (_spreader->_quoters_can_accept_modification())
{
Price new_price (order_update.price()); Quantity new_quantity (order_update.quantity());
SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data ();
// updating internal state
_spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity()));
// updating all active quoters
for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++)
Price price (u.price()); Quantity quantity(u.quantity());
_spreader->_bookkeeping_data.update_order (price, quantity);
// updating all active quoters, nothing to do with the hedgers
for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data.count(); q_idx++)
{
SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx);
SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(q_idx);
if (leg_data.leg_property_data.is_active_quoting())
leg_data.quoter().update_order_price_quantity (new_price, new_quantity);
leg_data.quoter().update_order_price_quantity (price, quantity);
}
// reporting state
_spreader->report_state (api::orderman::OrderStatus::OS_NEW);
}
}
void SpreaderWorkingStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&)
{
_spreader->_cancel_orders (true, true);
_spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL);
_spreader->_transform_to_WAITING_FOR_CANCEL_ALL ();
}
void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book)
{
SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data ();
SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data;
// this is a key->index lookup
SpreaderLegData& md_leg = bookkeeping_data.get_leg_data(book.security_key());
// updating md state (this is the only place where its done)
@@ -67,22 +62,20 @@ void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book)
}
// send md to hedgers hedging this security only
for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++)
{
SpreaderHedgerData& h = md_leg.get_hedger(h_idx);
h.hedger().on_book(cid, book);
}
md_leg.get_hedger(h_idx).hedger().on_book(cid, book);
}
void SpreaderWorkingStateWorker::on_time(const TimeStamp&)
void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts)
{
SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data ();
SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data;
for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++)
{
SpreaderLegData& d = bookkeeping_data.get_leg_data(q_idx);
if (d.leg_property_data.is_active_quoting())
SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx);
if (leg_data.leg_property_data.is_active_quoting())
{
// same f'ing timestamp
// d.quoter().on_time (ts);
}
leg_data.quoter().on_time(ts);
for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++)
leg_data.get_hedger(h_idx).hedger().on_time (ts);
}
}
}
void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg)
@@ -91,7 +84,6 @@ void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLe
// this is because the error message could also have status changes
leg_data.quoter().update_order_status (leg_data.order_update_message());
_spreader->_cancel_orders (true, true);
_spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL);
_spreader->_transform_to_WAITING_FOR_CANCEL_ALL ();
}
void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price)
@@ -104,10 +96,9 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg
// 5. init the hedger
leg_data.order_update_message().update (status, filled_quantity, average_price, nullptr);
leg_data.quoter().update_order_status (leg_data.order_update_message());
SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data ();
for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++)
for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data.count(); q_idx++)
{
bts::orderman::SpreaderLegData other_leg_data = bookkeeping_data.get_leg_data (q_idx);
bts::orderman::SpreaderLegData other_leg_data = _spreader->_bookkeeping_data.get_leg_data (q_idx);
if (q_idx != leg_data.leg_property_data.leg_index)
{
// if it is an actively quoting leg, inform the quoter about it
@@ -124,31 +115,34 @@ void SpreaderWorkingStateWorker::on_quoter_order_status_update(bts::orderman::Sp
leg_data.order_update_message().update (status);
leg_data.quoter().update_order_status (leg_data.order_update_message());
}
void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*)
void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg)
{
// TODO:update hedger order state
//leg_data.order_update_message().update(status, filled_quantity, average_price, err_msg);
SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key);
if (hedger_data != nullptr)
{
hedger_data->order_update_message().update(status, filled_quantity, average_price, err_msg);
hedger_data->hedger().on_order_update(hedger_data->order_update_message());
}
_spreader->_cancel_orders (true, true);
_spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL);
_spreader->_transform_to_WAITING_FOR_CANCEL_ALL ();
}
void SpreaderWorkingStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price)
void SpreaderWorkingStateWorker::on_hedger_order_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price)
{
// TODO
bts_assert_msg (false, "Illegal Spreader operation {WORKING,on_hedger_order_upate}");
SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key);
if (hedger_data != nullptr)
{
hedger_data->order_update_message().update(status, filled_quantity, average_price, nullptr);
hedger_data->hedger().on_order_update(hedger_data->order_update_message());
}
}
void SpreaderWorkingStateWorker::on_external_error(std::string const&)
{
_spreader->_cancel_orders (true, true);
_spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL);
_spreader->_transform_to_WAITING_FOR_CANCEL_ALL ();
}
void SpreaderWorkingStateWorker::on_check_termination()
{
if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state())
{
_spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); // TODO, figure out if it was filled or cxl'ed
_spreader->_transform_to_END ();
}
}
}}