Spark-267 better logging
This commit is contained in:
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;
|
||||
|
||||
+2
-6
@@ -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 ()
|
||||
{
|
||||
}
|
||||
|
||||
}}
|
||||
+19
-14
@@ -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 ();
|
||||
}
|
||||
}
|
||||
}}
|
||||
+6
-5
@@ -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()
|
||||
{}
|
||||
|
||||
+37
-43
@@ -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 ();
|
||||
}
|
||||
}
|
||||
}}
|
||||
Reference in new issue
Block a user