diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index be177b970..ca76f544e 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -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();} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index 814e399e5..9677c9ff3 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -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; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp index 7197fba75..7d6ca0207 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp @@ -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 () { } - }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp index 03f8df81c..fbb902cc1 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp @@ -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 (); - } } }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp index 64f8d11e8..f154e91c9 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp @@ -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() {} diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 865094ca0..029baec1a 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -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 (); - } } }} \ No newline at end of file