diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index 7b813cc78..8b4f8f381 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -60,12 +60,12 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db, : SpreaderOrderBase(db, f, k, cor), me(new PImpl(false, cor, db, k, api::orderman::OS_UNACKNOWLEDGED, Price(cor.spreader().price()), - Quantity(cor.spreader().quantity()), std::string(""))), - _state(State::START) + Quantity(cor.spreader().quantity()), std::string(""))) { LOG(OrderMan, Diag, "creating new SpreaderOrder. request: {}", utils::pb::to_string(cor)); bts_assert(cor.has_spreader()); bts_assert(cor.spreader().security().has_synthetic()); + _transform_to_START (); } SpreaderOrder::~SpreaderOrder () {} @@ -73,8 +73,7 @@ SpreaderOrder::~SpreaderOrder () {} void SpreaderOrder::init() { if (me->resurrected) return; - LOG(OrderMan, Diag, "Init"); - report_state(); + LOG(OrderMan, Diag, "SpreaderOrder.Init"); if (_state == State::START) { _init_state(); @@ -92,12 +91,8 @@ void SpreaderOrder::init() void SpreaderOrder::on_connect() { - if (me->resurrected) - { - // ignoring _resurrected (from disk) orders for now - return; - } - LOG(OrderMan, Diag, "on_connect"); + if (me->resurrected) return; + LOG(OrderMan, Diag, "Spreaderorder.on_connect"); if (_state == State::START) bts_assert(false); else if (_state == State::WAITING_FOR_FIRST_CONNECT) @@ -137,15 +132,11 @@ void SpreaderOrder::on_update(const api::orderman::UpdateSpreaderOrder& u) { LOG(OrderMan,Diag,"on_update SpreaderOrder. order: {}",utils::pb::to_string(u)); if (me->resurrected) return; - // TODO : send status updates out + bool success = false; if (_state == State::START) - { bts_assert(false); - } else if (_state == State::WAITING_FOR_FIRST_CONNECT) - { - // TODO send a rejection out - } + { } else if (_state == State::WORKING) { // check if all quoters can accept the change (a price, qty @@ -163,26 +154,28 @@ void SpreaderOrder::on_update(const api::orderman::UpdateSpreaderOrder& u) } if (accept_changes) { + me->price = Price(u.price()); + me->quantity = Quantity(u.quantity ()); for (size_t q_idx = 0; q_idx < _bookkeeping_data->count(); q_idx++) { SpreaderLegData& leg_data = _bookkeeping_data->get_leg_data(q_idx); if (leg_data.leg_property_data.is_active_quoting()) - leg_data.update_order_price_quantity(Price(u.price()), Quantity(u.quantity())); + leg_data.quoter().update_order_price_quantity (Price(u.price()), Quantity(u.quantity())); } + success = true; } } else if (_state == State::WAITING_FOR_CANCEL_ALL) - { - // TODO send a rejection out - } + { } else if (_state == State::END) - { - // TODO send a rejection out - } + { } + if (!success) + me->status = api::orderman::OrderStatus::OS_REJECTED_BY_SPARK; + report_state (); } void SpreaderOrder::on_cancel(const api::orderman::CancelSpreaderOrder& c) -{ +{ LOG(OrderMan,Diag,"on_cancel SpreaderOrder. order: {}",utils::pb::to_string(c)); if (me->resurrected) return; if (_state == State::START) @@ -227,7 +220,7 @@ void SpreaderOrder::on_book(TickToTradeCorID cid, Book const& 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); + SpreaderHedgerData& h = md_leg.get_hedger(h_idx); h.hedger.update_md(); } } @@ -256,8 +249,7 @@ void SpreaderOrder::on_child_update(OrderKey orderkey, if (me->resurrected) return; using namespace bts::spreader; static std::string empty; - LOG(OrderMan,Diag, - "on_child_update SpreaderOrder." + LOG(OrderMan,Diag, "SpreaderOrder.on_child_update " "k: {} status: {} filled_qty: {} avg_price: {} reject_msg: {}", orderkey.value(), status, filled_quantity.value(), average_price.value(), error_msg ? empty:*error_msg); if (_state == State::START) @@ -266,27 +258,26 @@ void SpreaderOrder::on_child_update(OrderKey orderkey, bts_assert(false); else if (_state == State::WORKING) { - if (_order_update_has_error(error_msg)) - _handle_order_error(); + SpreaderLegData* leg_data_ptr = _bookkeeping_data->find_leg_from_quoter_orderkey(orderkey); + if (leg_data_ptr != nullptr) + { + SpreaderLegData& leg_data = *(leg_data_ptr); + leg_data.order_update_message().update(status, filled_quantity, average_price, error_msg); + if (leg_data.order_update_message().has_error()) + _handle_order_error(); + else + _handle_quoter_order_update(leg_data); + } else { - SpreaderLegData* q_leg_data_ptr = _bookkeeping_data->find_leg_from_quoter_orderkey(orderkey); - if (q_leg_data_ptr != NULL) + // should be a hedge order then + SpreaderHedgerData* hedger_data = _bookkeeping_data->find_hedger_from_orderkey(orderkey); + if (hedger_data != nullptr) { - SpreaderLegData& q_leg_data = *(q_leg_data_ptr); - SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, q_leg_data.filled_quantity, q_leg_data.avergage_filled_price); - _handle_quoter_order_update(q_leg_data, update_message); - } - else - { - // should be a hedge order then - SpreaderHedgerData* hedger_data = _bookkeeping_data->find_hedger_from_orderkey(orderkey); - if (hedger_data != NULL) - { - SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, hedger_data->filled_quantity, hedger_data->avergage_filled_price); - hedger_data->update_fill(filled_quantity); - hedger_data->hedger.update_order_state(update_message); - } + /// TODO + bts_assert (false); + // hedger_data->update_fill(filled_quantity); + // hedger_data->hedger.update_order_state(update_message); } } } @@ -294,20 +285,20 @@ void SpreaderOrder::on_child_update(OrderKey orderkey, { // all it has to do SpreaderLegData* q_leg_data_ptr = _bookkeeping_data->find_leg_from_quoter_orderkey(orderkey); - if (q_leg_data_ptr != NULL) + if (q_leg_data_ptr != nullptr) { SpreaderLegData& q_leg_data = *(q_leg_data_ptr); - SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, q_leg_data.filled_quantity, q_leg_data.avergage_filled_price); - q_leg_data_ptr->quoter().update_order_status(update_message); + q_leg_data.order_update_message().update (status, filled_quantity, average_price, error_msg); + q_leg_data.quoter().update_order_status(q_leg_data.order_update_message()); } else { SpreaderHedgerData* hedger_data = _bookkeeping_data->find_hedger_from_orderkey(orderkey); - if (hedger_data != NULL) + if (hedger_data != nullptr) { - SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, hedger_data->filled_quantity, hedger_data->avergage_filled_price); - hedger_data->update_fill(filled_quantity); - hedger_data->hedger.update_order_state(update_message); + // SpreaderOrderUpdateMessage update_message(orderkey, status, filled_quantity, average_price, hedger_data->filled_quantity, hedger_data->avergage_filled_price); + // hedger_data->update_fill(filled_quantity); + // hedger_data->hedger.update_order_state(update_message); } } if (_all_quoter_orders_in_terminal_state() && _all_hedger_orders_in_terminal_state()) @@ -379,13 +370,22 @@ void SpreaderOrder::_init_state() leg_idx++; } bts_assert(leg_data_vector.size() > 0); - _bookkeeping_data = std::make_unique(sec, leg_data_vector); + _bookkeeping_data = std::make_unique(sec, leg_data_vector); +} + +void SpreaderOrder::_transform_to_START() +{ + _state = State::START; + me->status = api::orderman::OrderStatus::OS_PENDING_NEW; + report_state (); } void SpreaderOrder::_transform_to_WAITING_FOR_FIRST_CONNECTION() { bts_assert(_state == State::START); _state = State::WAITING_FOR_FIRST_CONNECT; + me->status = api::orderman::OrderStatus::OS_PENDING_NEW; + report_state (); } void SpreaderOrder::_transform_to_WORKING() { @@ -405,24 +405,31 @@ void SpreaderOrder::_transform_to_WORKING() if (leg_data.leg_property_data.is_active_quoting()) leg_data.quoter().init(); } + me->status = api::orderman::OrderStatus::OS_NEW; + report_state(); } void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL() { bts_assert(_state == State::WORKING); - _state = State::WAITING_FOR_CANCEL_ALL; + _state = State::WAITING_FOR_CANCEL_ALL; _cancel_orders(true, true); + me->status = api::orderman::OrderStatus::OS_PENDING_CANCEL; + report_state(); } void SpreaderOrder::_transform_to_END() { bts_assert(_state == State::WORKING || _state == State::WAITING_FOR_CANCEL_ALL); _state = State::END; + me->status = api::orderman::OrderStatus::OS_CANCELED; // TODO, this should is not just cancelled + report_state(); } void SpreaderOrder::_handle_order_error() { _transform_to_WAITING_FOR_CANCEL_ALL(); } -void SpreaderOrder::_handle_quoter_order_update(SpreaderLegData& leg_data, const SpreaderOrderUpdateMessage& update_message) +void SpreaderOrder::_handle_quoter_order_update(SpreaderLegData& leg_data) { + const SpreaderOrderUpdateMessage& update_message = leg_data.order_update_message(); // quoter needs to update, if there is a fill, the quoter // will update its order quantity leg_data.quoter().update_order_status(update_message); @@ -430,20 +437,15 @@ void SpreaderOrder::_handle_quoter_order_update(SpreaderLegData& leg_data, const // i. update leg_data's price and quantity // ii. tell other quotes of the fill // iii send hedges - Quantity this_fill_quantity; Price this_fill_price; - if (update_message.update_fill_price_quantity(this_fill_quantity, this_fill_price)) + if (update_message.has_fills()) { - leg_data.filled_quantity = update_message.filled_quantity; - leg_data.avergage_filled_price = update_message.average_price; for (size_t idx = 0; idx < _bookkeeping_data->count(); idx++) - { if (idx != leg_data.leg_property_data.leg_index) { if (leg_data.leg_property_data.is_active_quoting()) - leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data.leg_index, this_fill_quantity); + leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data.leg_index, update_message.last_update_filled_quantity()); //_send_hedge(leg_data.leg_property_data.leg_index, this_fill_price, this_fill_quantity, idx);// TODO } - } } } void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) @@ -501,9 +503,27 @@ void SpreaderOrder::_compute_hedge_price_quantity(size_t, void SpreaderOrder::report_state() { - report_state_change( - SpreaderOrderState{ - me->status, me->price,me->quantity,me->reject_msg.empty() ? nullptr : &me->reject_msg }); +// report_state_change(SpreaderOrderState{ +// me->status, +// me->price, +// me->quantity, +// me->reject_msg.empty() ? nullptr : &me->reject_msg +// }); +} + +bool SpreaderOrder::can_resolve_securties () +{ + const bts::api::orderman::CreateSpreaderOrder& cor = me->create_order_request.spreader(); + const bts::api::Security& sec = cor.security(); + for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) + { + const bts::api::ContractLeg& leg = *it; + bts::SecurityKey leg_key = bts::SecurityKey (leg.security().id()); + api::Security const * db_sec = me->db.resolve (leg_key); + if (db_sec == nullptr) + return false; + } + return true; } /*******************************************************************************/ diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index 76834cd5d..2abc52dff 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -82,12 +82,13 @@ public: SingleLegQuoter& quoter (size_t index); private: void _init_state (); + void _transform_to_START(); void _transform_to_WAITING_FOR_FIRST_CONNECTION(); void _transform_to_WORKING(); void _transform_to_WAITING_FOR_CANCEL_ALL(); void _transform_to_END(); void _handle_order_error(); - void _handle_quoter_order_update(SpreaderLegData& leg_data, const SpreaderOrderUpdateMessage& update_message); + void _handle_quoter_order_update(SpreaderLegData& leg_data); // 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); @@ -98,11 +99,11 @@ private: bool _all_hedger_orders_in_terminal_state(); void _send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_to_hedge_index); void _compute_hedge_price_quantity(size_t filled_leg_index, - Price filled_price, Quantity filled_quantity, - size_t hedged_index, - Price& hedge_price, Quantity& hedge_quantity); - bool _order_update_has_error(std::string const *error_msg) { return error_msg != NULL; } + Price filled_price, Quantity filled_quantity, + size_t hedged_index, + Price& hedge_price, Quantity& hedge_quantity); void report_state(); + bool can_resolve_securties(); private: struct PImpl; std::unique_ptr me; diff --git a/src/server/sparkd/spreader/SingleLegQuoter.cpp b/src/server/sparkd/spreader/SingleLegQuoter.cpp index 8615f1be9..39a4513ba 100644 --- a/src/server/sparkd/spreader/SingleLegQuoter.cpp +++ b/src/server/sparkd/spreader/SingleLegQuoter.cpp @@ -166,7 +166,7 @@ void SingleLegQuoter::_handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& e if (event_data.external_event == ExternalEvents::OrderStateUpdate) { const SpreaderOrderUpdateMessage& order_udpate_message = *(event_data.order_update_message); - _price_quantity_state.update_filled_quantity(order_udpate_message.filled_quantity); + _price_quantity_state.update_filled_quantity(order_udpate_message.filled_quantity()); if (order_udpate_message.terminal_status()) _transform_to_END(); else if (order_udpate_message.has_error()) @@ -252,7 +252,7 @@ void SingleLegQuoter::_handle_events_in_WORKING(const EventData& event_data) if (event_data.external_event == ExternalEvents::OrderStateUpdate) { const SpreaderOrderUpdateMessage& order_update_message = *(event_data.order_update_message); - _price_quantity_state.update_filled_quantity(order_update_message.filled_quantity); + _price_quantity_state.update_filled_quantity(order_update_message.filled_quantity()); if (order_update_message.terminal_status()) _transform_to_END(); else if (order_update_message.has_error()) @@ -317,7 +317,7 @@ void SingleLegQuoter::_handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& if (event_data.external_event == ExternalEvents::OrderStateUpdate) { const SpreaderOrderUpdateMessage& order_udpate_message = *(event_data.order_update_message); - _price_quantity_state.update_filled_quantity(order_udpate_message.filled_quantity); + _price_quantity_state.update_filled_quantity(order_udpate_message.filled_quantity()); if (order_udpate_message.terminal_status()) _transform_to_END(); } diff --git a/src/server/sparkd/spreader/SpreaderLegData.h b/src/server/sparkd/spreader/SpreaderLegData.h index 527d3abc1..b67b2ea3c 100644 --- a/src/server/sparkd/spreader/SpreaderLegData.h +++ b/src/server/sparkd/spreader/SpreaderLegData.h @@ -4,58 +4,52 @@ #include "SingleLegQuoter.h" #include "SingleFillHedger.h" #include "SpreaderHedgerData.h" +#include "SpreaderOrderUpdateMessage.h" #include namespace bts{ namespace spreader{ -// all the data for a leg, mainly +// all the data for a leg : // 1. leg property data -// 2. market data (book) -// 3. quoter -// 4. order key -// 5. order price and quantity +// 2. quoter +// 3. market data (book) +// 4. order update // 6. all the hedgers for this leg (ie when fills happens // on other legs, and they are hedged in this leg) +// the higher level objects are returned by ref to mutate +// their state class SpreaderLegData { public: const LegPropertyData leg_property_data; -private: - SingleLegQuoter _quoter; - orderman::OrderKey _order_key; -public: - Quantity filled_quantity; - Price avergage_filled_price; private: + SingleLegQuoter _quoter; orderman::Book _book; + SpreaderOrderUpdateMessage _order_update_message; std::vector _hedger_data_vector; public: - SpreaderLegData(const LegPropertyData& leg_property_data_arg, + SpreaderLegData(const LegPropertyData& leg_property_data_arg, SingleLegQuoter quoter_arg, - orderman::OrderKey order_key_arg) + orderman::OrderKey orderkey) : leg_property_data(leg_property_data_arg), _quoter (quoter_arg), - _order_key (order_key_arg), - filled_quantity (Quantity (0)), - avergage_filled_price (Price (0)), _book(), - _hedger_data_vector() {} - // set_book copies book by value - void set_book(const orderman::Book& book_arg) {_book = book_arg;} - orderman::Book& book () {return _book;} + _order_update_message (SpreaderOrderUpdateMessage (orderkey)), + _hedger_data_vector() {} + SingleLegQuoter& quoter() {return _quoter;} - orderman::OrderKey order_key() {return _order_key;} - void update_order_price_quantity (Price new_average_filled_price, Quantity new_filled_quantity) - { - filled_quantity = new_filled_quantity; - avergage_filled_price = new_average_filled_price; - } + orderman::Book& book () {return _book;} + // called for every book update. the values + // are copied by value + void set_book(const orderman::Book& book_arg) {_book = book_arg;} + SpreaderOrderUpdateMessage& order_update_message () {return _order_update_message;} + orderman::OrderKey order_key() {return _order_update_message.key;} // returns the number of active hedgers size_t n_hedgers() { return _hedger_data_vector.size(); } // returns the hedger at a given index SpreaderHedgerData& get_hedger(size_t index) {return _hedger_data_vector[index];} - // returns a hedger that is working on orderkey + // returns a hedger from its orderkey SpreaderHedgerData* find_hedger_from_orderkey(orderman::OrderKey orderkey) { for (auto h_it = _hedger_data_vector.begin(); h_it != _hedger_data_vector.end(); ++h_it) diff --git a/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h b/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h index abb2e484c..5d0f91134 100644 --- a/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h +++ b/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h @@ -11,73 +11,57 @@ namespace bts { namespace spreader { -// message class (should not be cached) to pass orderevents -// from the spreader to the quoter and hedger (unused) +// this represents the last update message (and some derived data) +// for an order. its part of the quoter and hedger data class SpreaderOrderUpdateMessage { public: // original order_state passed from the engine infrastructure // (do not cache it) const orderman::OrderKey key; - api::orderman::OrderStatus status; - Quantity filled_quantity; - Price average_price; - Quantity last_update_filled_quantity; - Price last_update_average_price; - //std::string const *error_msg; - SpreaderOrderUpdateMessage(orderman::OrderKey orderkey_arg, - api::orderman::OrderStatus status_arg, - Quantity filled_quantity_arg, - Price avg_price_arg, - Quantity previous_filled_quantity_arg, - Price previous_avg_price_arg) - //std::string const *error_msg_arg) +private: + api::orderman::OrderStatus _status; + Price _average_price; + Quantity _filled_quantity; + Price _last_update_filled_price; + Quantity _last_update_filled_quantity; + bool _has_error; +public: + SpreaderOrderUpdateMessage(orderman::OrderKey orderkey_arg) : key(orderkey_arg), - status(status_arg), - filled_quantity(filled_quantity_arg), - average_price(avg_price_arg), - last_update_filled_quantity(previous_filled_quantity_arg), - last_update_average_price(previous_avg_price_arg) - //error_msg(error_msg_arg) + _status (api::orderman::OrderStatus::OS_UNACKNOWLEDGED), + _average_price(Price(0)), + _filled_quantity(Quantity (0)), + _last_update_filled_price(Price(0)), + _last_update_filled_quantity(Quantity(0)), + _has_error (false) { } - bool terminal_status() const { return SpreaderUtils::order_in_terminal_state(status); } - - bool acknowledged () const {return SpreaderUtils::order_acknowledged (status);} - - bool has_error() const { return key.value() == 0; }// return error_msg != NULL; - - bool has_fills() const - { - return filled_quantity.value() != last_update_filled_quantity.value(); - } + Quantity filled_quantity () const {return _filled_quantity;} + Price last_update_filled_price () const {return _last_update_filled_price;} + Quantity last_update_filled_quantity () const {return _last_update_filled_quantity;} + bool terminal_status() const { return SpreaderUtils::order_in_terminal_state(_status); } + bool acknowledged () const {return SpreaderUtils::order_acknowledged (_status);} + bool has_error() const { return _has_error; } + bool has_fills() const {return _last_update_filled_quantity.value() != 0;} void update(api::orderman::OrderStatus status_arg, Quantity filled_quantity_arg, Price average_price_arg, - std::string const *) + std::string const *err_msg) { - status = status_arg; - bts_assert(filled_quantity_arg.value() >= filled_quantity.value()); - last_update_filled_quantity = Quantity(filled_quantity_arg.value() - filled_quantity.value()); - if (last_update_filled_quantity.value() > 0) - last_update_average_price = Price((average_price_arg.value() * filled_quantity_arg.value() - average_price.value() * filled_quantity.value()) / last_update_filled_quantity.value()); - filled_quantity = filled_quantity_arg; - average_price = average_price_arg; - } - - bool update_fill_price_quantity(Quantity& this_fill_quantity, Price& this_fill_price) const - { - if (filled_quantity.value() != last_update_filled_quantity.value()) + _status = status_arg; + bts_assert(filled_quantity_arg.value() >= _filled_quantity.value()); + _last_update_filled_quantity = Quantity(filled_quantity_arg.value() - _filled_quantity.value()); + if (_last_update_filled_quantity.value() > 0) { - bts_assert(filled_quantity.value() > last_update_filled_quantity.value()); - this_fill_quantity = Quantity(filled_quantity.value() - last_update_filled_quantity.value()); - double this_price = (average_price.value()*filled_quantity.value() - last_update_average_price.value()*last_update_filled_quantity.value()) / this_fill_quantity.value(); - this_fill_price = Price(this_price); - return true; + double sum = average_price_arg.value() * filled_quantity_arg.value(), + previous_sum = _average_price.value() * _filled_quantity.value(); + _last_update_filled_price = Price((sum - previous_sum)/_last_update_filled_quantity.value()); } - else - return false; - } + _filled_quantity = filled_quantity_arg; + _average_price = average_price_arg; + _has_error = err_msg != nullptr; + } }; }} \ No newline at end of file