From 9792f7d0a1397c8730bbc6a0159122b4b7be161b Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 31 Oct 2017 13:10:50 -0400 Subject: [PATCH 1/6] moving state and price/qty inner classes out from SingleFillHedger --- .../sparkd/spreader/SingleFillHedger.cpp | 166 +++--------------- src/server/sparkd/spreader/SingleFillHedger.h | 133 ++------------ .../spreader/hedger/HedgePriceQuantityState.h | 47 +++++ .../spreader/hedger/IHedgerStateWorker.h | 2 + .../hedger_states/HedgerEndStateWorker.cpp | 1 + .../hedger_states/HedgerEndStateWorker.h | 1 + .../hedger_states/HedgerStartStateWorker.cpp | 1 + .../hedger_states/HedgerStartStateWorker.h | 1 + .../hedger/hedger_states/HedgerState.h | 14 ++ .../HedgerWaitingForCancelAckStateWorker.cpp | 1 + .../HedgerWaitingForCancelAckStateWorker.h | 1 + .../HedgerWaitingForFirstAck.cpp | 1 + .../hedger_states/HedgerWaitingForFirstAck.h | 1 + .../HedgerWaitingForFirstAckCancelled.cpp | 1 + .../HedgerWaitingForFirstAckCancelled.h | 1 + .../HedgerWorkingStateWorker.cpp | 1 + .../hedger_states/HedgerWorkingStateWorker.h | 1 + 17 files changed, 110 insertions(+), 264 deletions(-) create mode 100644 src/server/sparkd/spreader/hedger/HedgePriceQuantityState.h create mode 100644 src/server/sparkd/spreader/hedger/hedger_states/HedgerState.h diff --git a/src/server/sparkd/spreader/SingleFillHedger.cpp b/src/server/sparkd/spreader/SingleFillHedger.cpp index 98155979d..28cd734f2 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.cpp +++ b/src/server/sparkd/spreader/SingleFillHedger.cpp @@ -3,177 +3,59 @@ #include "ISpreaderManager.h" #include "SpreaderUtils.h" #include "SpreaderOrderUpdateMessage.h" +#include "server/sparkd/spreader/hedger/hedger_states/HedgerState.h" namespace bts { namespace orderman { SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager, const LegPropertyData& leg_property_data, - bts::orderman::SpreaderOrderBase::ChildOrder, + bts::orderman::SpreaderOrderBase::ChildOrder order, bts::Price hedge_price, bts::Quantity hedge_quantity, api::Side hedge_side) : _spreader_manager(spreader_manager), - _leg_property_data (leg_property_data), + _leg_property_data (leg_property_data), + _order (order), _price_quantity_state(hedge_price, hedge_quantity, hedge_side), - _state(HedgerState::START), _curr_state_worker (nullptr) { } - +bool SingleFillHedger::is_active_order() const +{ + bool is_not_active = _curr_state_worker->state() == HedgerState::START || + _curr_state_worker->state() == HedgerState::END; + return !is_not_active; +} +bool SingleFillHedger::is_terminal_state () const +{ + return _curr_state_worker->state() != HedgerState::END; +} +bool SingleFillHedger::accepting_price_change() const { return _curr_state_worker->state() == HedgerState::WORKING; } +Quantity SingleFillHedger::remaining_to_fill() const { return _price_quantity_state.remaining_to_fill(); } void SingleFillHedger::init() { _curr_state_worker->init(); - transform_to_WAITING_FOR_FIRST_ACK(); } - -bool SingleFillHedger::is_active_order() const { return _state != HedgerState::START && _state != HedgerState::END; } - -bool SingleFillHedger::is_terminal_state () const {return _state != HedgerState::END;} - -bool SingleFillHedger::accepting_price_change() { return _state == HedgerState::WORKING; } - -Quantity SingleFillHedger::remaining_to_fill() { return _price_quantity_state.remaining_to_fill(); } - void SingleFillHedger::on_order_update(const SpreaderOrderUpdateMessage& order_update_message) { - SingleFillHedger::EventData event_data (&order_update_message); - _fire_event(event_data); + _curr_state_worker->on_order_update (order_update_message); } - -void SingleFillHedger::on_book(TickToTradeCorID, const Book&) +void SingleFillHedger::on_book(TickToTradeCorID corid, const Book& book) { - SingleFillHedger::EventData event_data(ExternalHedgerEvents::MDUpdate); - _fire_event(event_data); + _curr_state_worker->on_book (corid, book); } - void SingleFillHedger::cancel_hedge() { - SingleFillHedger::EventData event_data(ExternalHedgerEvents::HedgeCancel); - _fire_event(event_data); + _curr_state_worker->cancel (); } - -/***************************************************************************/ -/********************External Event Handling in START***********************/ -/***************************************************************************/ -void SingleFillHedger::_handle_events_in_START(const EventData&) +void SingleFillHedger::terminate () { - // start can get no events - bts_assert(false); + _curr_state_worker->terminate(); } - -/***************************************************************************/ -/*********External Event Handling in WAITING_FOR_FIRST_ACK******************/ -/***************************************************************************/ -void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK() +void SingleFillHedger::on_time (const bts::TimeStamp& ts) { - bts_assert(_state == HedgerState::START); - _state = HedgerState::WAITING_FOR_FIRST_ACK; - // The order is sent for the one and only time here - // TODO check for market orders pre hedge rule - //_order_key = _spreader_manager.send_limit_order(_order_template, _price_quantity_state.target_price(), _price_quantity_state.target_quantity()); + _curr_state_worker->on_time (ts); } - -void SingleFillHedger::_handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data) -{ - if (event_data.external_event == ExternalHedgerEvents::OrderState) - { - const SpreaderOrderUpdateMessage& update_message = *(event_data.order_state); - if (update_message.terminal_status()) - transform_to_END(); - else if (update_message.has_error()) - transform_to_WAITING_FOR_CANCEL_ACK(); - else - _transform_to_WORKING(); - } - else if (event_data.external_event == ExternalHedgerEvents::MDUpdate) {} - // md will have no impact when waiting for order ack - else if (event_data.external_event == ExternalHedgerEvents::UserHedgePriceChange) - // accept_changes should have returned false, forbiding price changes - bts_assert(false); - else if (event_data.external_event == ExternalHedgerEvents::HedgeCancel) - transform_to_WAITING_FOR_CANCEL_ACK(); -} -/***************************************************************************/ -/*******************External Event Handling in WORKING**********************/ -/***************************************************************************/ -void SingleFillHedger::_transform_to_WORKING() -{ - bts_assert(_state == HedgerState::WAITING_FOR_FIRST_ACK); - _state = HedgerState::WORKING; - // nothing to do here, since any changes in the previous - // state were rejected -} -void SingleFillHedger::_handle_events_in_WORKING(const EventData& event_data) -{ - if (event_data.external_event == ExternalHedgerEvents::OrderState) - { - const SpreaderOrderUpdateMessage& update_message = *(event_data.order_state); - if (update_message.terminal_status()) - transform_to_END(); - else if (update_message.has_error()) - transform_to_WAITING_FOR_CANCEL_ACK(); - } - else if (event_data.external_event == ExternalHedgerEvents::MDUpdate) - { - // TODO apply post hedge rule - } - else if (event_data.external_event == ExternalHedgerEvents::UserHedgePriceChange) - { - _price_quantity_state.udpate_target_price(event_data.hedge_price); - // TODO - //_spreader_manager.update_order(_order_key, _price_quantity_state.target_price(), _price_quantity_state.target_quantity()); - } - else if (event_data.external_event == ExternalHedgerEvents::HedgeCancel) - transform_to_WAITING_FOR_CANCEL_ACK(); -} -/***************************************************************************/ -/*********External Event Handling in WAITING_FOR_CANCEL_ACK*****************/ -/***************************************************************************/ -void SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK() -{ - bts_assert(_state == HedgerState::WAITING_FOR_FIRST_ACK || _state == HedgerState::WORKING); - _state = HedgerState::WAITING_FOR_CANCEL_ACK; - // TODO - //_spreader_manager.cancel_order(_order_key); -} -void SingleFillHedger::_handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data) -{ - if (event_data.external_event == ExternalHedgerEvents::OrderState) - { - const SpreaderOrderUpdateMessage& update_message = *(event_data.order_state); - if (update_message.terminal_status()) - transform_to_END(); - } -} -/***************************************************************************/ -/*********************External Event Handling in END************************/ -/***************************************************************************/ -void SingleFillHedger::transform_to_END() -{ - bts_assert(_state == HedgerState::WAITING_FOR_FIRST_ACK || _state == HedgerState::WORKING); - _state = HedgerState::END; -} -void SingleFillHedger::_handle_events_in_END(const EventData&) -{ -} - -void SingleFillHedger::_fire_event(const EventData& event_data) -{ - if (_state == HedgerState::START) - _handle_events_in_START(event_data); - else if (_state == HedgerState::WAITING_FOR_FIRST_ACK) - _handle_events_in_WAITING_FOR_FIRST_ACK(event_data); - else if (_state == HedgerState::WORKING) - _handle_events_in_WORKING(event_data); - else if (_state == HedgerState::WAITING_FOR_CANCEL_ACK) - _handle_events_in_WAITING_FOR_CANCEL_ACK(event_data); - else if (_state == HedgerState::END) - _handle_events_in_END(event_data); -} - -void SingleFillHedger::on_time (const bts::TimeStamp&) -{} - }} diff --git a/src/server/sparkd/spreader/SingleFillHedger.h b/src/server/sparkd/spreader/SingleFillHedger.h index 00ccd2148..a94737d07 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.h +++ b/src/server/sparkd/spreader/SingleFillHedger.h @@ -5,6 +5,7 @@ #include "lib/api/services/OrderService.pb.h" #include "lib/utils/bts_chrono.h" #include "server/sparkd/orderman/utils/orderman_utils.h" +#include "server/sparkd/spreader/hedger/HedgePriceQuantityState.h" #include "server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h" #include "server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h" #include "server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h" @@ -16,137 +17,24 @@ class LegPropertyData; class SpreaderOrderUpdateMessage; class SingleFillHedger { - enum class ExternalHedgerEvents - { - // order status update (or fills) - OrderState, - Timer, - // market data update from the exchange - MDUpdate, - // user modification of the hedger price - UserHedgePriceChange, - // cancel of this hedge order - HedgeCancel, - }; - - enum class HedgerState - { - START, - WAITING_FOR_FIRST_ACK, - WAITING_FOR_FIRST_ACK_CANCELLED, - WORKING, - WAITING_FOR_CANCEL_ACK, - END - }; - - class EventData - { - public: - const ExternalHedgerEvents external_event; - const SpreaderOrderUpdateMessage* order_state; - const Price hedge_price; - - EventData(const SpreaderOrderUpdateMessage* order_state_arg) - : - external_event(ExternalHedgerEvents::OrderState), - order_state(order_state_arg), - hedge_price(0.0) - {} - EventData(Price hedge_price_arg) - : - external_event(ExternalHedgerEvents::UserHedgePriceChange), - order_state(NULL), - hedge_price(hedge_price_arg) - {} - EventData(ExternalHedgerEvents external_event_arg) - : - external_event(external_event_arg), - order_state(NULL), - hedge_price(0.0) - {} - private: - EventData() - : - external_event(ExternalHedgerEvents::Timer), - order_state(NULL), - hedge_price(0.0) - {} - }; - - // price and quantity state for the hedger is kept here - class HedgePriceQuantityState - { - private: - // price at which to get the fill. this could - // be modifie dby the user - Price _target_price; - // this can never be modified - const Quantity _target_quantity; - const api::Side _side; - // filled part of the order, updated as fills - // come in - Quantity _aggregated_filled_quantity; - // the price of the "active" hedger order - Price _out_price; - public: - HedgePriceQuantityState(Price target_price, Quantity target_quantity, api::Side target_side) - : - _target_price(target_price), - _target_quantity(target_quantity), - _side (target_side), - _aggregated_filled_quantity(0) - { - } - // called when the user updates a working hedge order price - void udpate_target_price(Price new_target_price) { _target_price = new_target_price; } - // called as the hedge order gets filled - void update_fill(Quantity fill_quantity) - { - _aggregated_filled_quantity = Quantity(_aggregated_filled_quantity.value() + fill_quantity.value()); - } - // the hedger forgets everything and goes to the end state - Price target_price() const { return _target_price; } - Quantity target_quantity() const { return _target_quantity; } - Quantity aggregated_filled_quantity() const { return _aggregated_filled_quantity; } - // tells if the out_price and target_price are in sync - api::Side side() const { return _side; } - // this is the order quantity net of the fills - Quantity remaining_to_fill() const - { - uint32_t rv = _aggregated_filled_quantity.value() >= _target_quantity.value() ? 0 : _target_quantity.value() - _aggregated_filled_quantity.value(); - return Quantity(rv); - } - }; - private: ISpreaderManager& _spreader_manager; const LegPropertyData& _leg_property_data; + bts::orderman::SpreaderOrderBase::ChildOrder _order; HedgePriceQuantityState _price_quantity_state; - HedgerState _state; IHedgerStateWorker* _curr_state_worker; HedgerStartStateWorker _start_state_worker; - HedgerEndStateWorker _end_state_worker; -private: - /********************External Event Handling in START***********************/ - void _handle_events_in_START(const EventData& event_data); - /*********External Event Handling in WAITING_FOR_FIRST_ACK******************/ + HedgerEndStateWorker _end_state_worker; +private: void transform_to_WAITING_FOR_FIRST_ACK(); - void _handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data); - /*******************External Event Handling in WORKING**********************/ + void transform_to_WAITING_FOR_FIRST_ACK_CANCELLED (); void _transform_to_WORKING(); - void _handle_events_in_WORKING(const EventData& event_data); - /*********External Event Handling in WAITING_FOR_CANCEL_ACK******************/ void transform_to_WAITING_FOR_CANCEL_ACK(); - void _handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data); - /*********************External Event Handling in END*************************/ - void transform_to_END(); - void _handle_events_in_END(const EventData& event_data); - - void _fire_event(const EventData& event_data); + void transform_to_END(); public: SingleFillHedger(ISpreaderManager& spreader_manager, const LegPropertyData& leg_property_data, - bts::orderman::SpreaderOrderBase::ChildOrder child_order, + bts::orderman::SpreaderOrderBase::ChildOrder order, bts::Price hedge_price, bts::Quantity hedge_quantity, api::Side hedge_side); @@ -157,9 +45,9 @@ public: // it will never come back bool is_terminal_state () const; // true if the hedger can accept a price change - bool accepting_price_change(); + bool accepting_price_change() const; // this is the order quantity net of the fills (qty - filled_qty) - Quantity remaining_to_fill(); + Quantity remaining_to_fill() const; // hedger does not do anything until this void init(); // called by the spreader when there is an order update @@ -173,7 +61,8 @@ public: void cancel_hedge(); // immediatly terminates this hedger, without any attempts // to cancel the order - void terminate () { transform_to_END (); } + void terminate (); + // on the engine infrastructure time void on_time(const bts::TimeStamp&); }; diff --git a/src/server/sparkd/spreader/hedger/HedgePriceQuantityState.h b/src/server/sparkd/spreader/hedger/HedgePriceQuantityState.h new file mode 100644 index 000000000..91ab5a5d3 --- /dev/null +++ b/src/server/sparkd/spreader/hedger/HedgePriceQuantityState.h @@ -0,0 +1,47 @@ +#pragma once +#include "server/sparkd/orderman/utils/orderman_utils.h" +#include "lib/api/services/OrderService.pb.h" + +namespace bts{ +namespace orderman{ +// price and quantity state for the hedger is kept here +class HedgePriceQuantityState +{ +private: + // these const's are the price, qty and + // side of the hedger order + const Price _target_price; + const Quantity _target_quantity; + const api::Side _side; + // filled part of the order, updated as fills come in + Quantity _aggregated_filled_quantity; + // the price of the "active" hedger order + Price _out_price; +public: + HedgePriceQuantityState(Price target_price, Quantity target_quantity, api::Side target_side) + : + _target_price(target_price), + _target_quantity(target_quantity), + _side (target_side), + _aggregated_filled_quantity(0), + _out_price (_target_price) + { + } + // called as the hedge order gets filled + void update_fill(Quantity fill_quantity) + { + _aggregated_filled_quantity = Quantity(_aggregated_filled_quantity.value() + fill_quantity.value()); + } + Price target_price() const { return _target_price; } + Quantity target_quantity() const { return _target_quantity; } + api::Side side() const { return _side; } + Quantity aggregated_filled_quantity() const { return _aggregated_filled_quantity; } + Price out_price () const {return _out_price;} + // this is the order quantity net of the fills + Quantity remaining_to_fill() const + { + uint32_t rv = _aggregated_filled_quantity.value() >= _target_quantity.value() ? 0 : _target_quantity.value() - _aggregated_filled_quantity.value(); + return Quantity(rv); + } +}; +}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h b/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h index 980a70257..b4c37ec24 100644 --- a/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h +++ b/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h @@ -2,6 +2,7 @@ #include "server/sparkd/orderman/utils/orderman_utils.h" #include "lib/utils/bts_chrono.h" +#include "server/sparkd/spreader/hedger/hedger_states/HedgerState.h" namespace bts { namespace orderman { @@ -24,5 +25,6 @@ public: virtual void terminate() = 0; // time update from the infrastructure virtual void on_time(const TimeStamp&) = 0; + virtual HedgerState state () = 0; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp index 0e83762bb..27074ed13 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp @@ -17,4 +17,5 @@ void HedgerEndStateWorker::terminate() {} void HedgerEndStateWorker::on_time(const TimeStamp&) {} +HedgerState HedgerEndStateWorker::state() {return HedgerState::END;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h index ac54959c5..afabc297c 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h @@ -13,6 +13,7 @@ class HedgerEndStateWorker : public IHedgerStateWorker void cancel() override; void terminate() override; void on_time(const TimeStamp&) override; + HedgerState state () override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp index 158a80f06..0f0103398 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp @@ -17,4 +17,5 @@ void HedgerStartStateWorker::terminate() {} void HedgerStartStateWorker::on_time(const TimeStamp&) {} +HedgerState HedgerStartStateWorker::state() {return HedgerState::START;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h index e5fa211f8..7d9a6fa3b 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h @@ -13,6 +13,7 @@ class HedgerStartStateWorker : public IHedgerStateWorker void cancel() override; void terminate() override; void on_time(const TimeStamp&) override; + HedgerState state () override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerState.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerState.h new file mode 100644 index 000000000..2d1451b73 --- /dev/null +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerState.h @@ -0,0 +1,14 @@ +#pragma once + +namespace bts{ +namespace orderman{ +enum class HedgerState +{ + START, + WAITING_FOR_FIRST_ACK, + WAITING_FOR_FIRST_ACK_CANCELLED, + WORKING, + WAITING_FOR_CANCEL_ACK, + END +}; +}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp index 94de94adf..e05045eee 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp @@ -15,4 +15,5 @@ void HedgerWaitingForCancelAckStateWorker::terminate() {} void HedgerWaitingForCancelAckStateWorker::on_time(const TimeStamp&) {} +HedgerState HedgerWaitingForCancelAckStateWorker::state() {return HedgerState::WAITING_FOR_CANCEL_ACK;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h index 4d10da4fd..a9673ac43 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h @@ -13,6 +13,7 @@ class HedgerWaitingForCancelAckStateWorker : public IHedgerStateWorker void cancel() override; void terminate() override; void on_time(const TimeStamp&) override; + HedgerState state () override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp index 7186af5c1..486759ca3 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp @@ -15,4 +15,5 @@ void HedgerWaitingForFirstAck::terminate() {} void HedgerWaitingForFirstAck::on_time(const TimeStamp&) {} +HedgerState HedgerWaitingForFirstAck::state() {return HedgerState::WAITING_FOR_FIRST_ACK;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h index 784c5e8c6..5c46d6789 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h @@ -13,6 +13,7 @@ class HedgerWaitingForFirstAck : public IHedgerStateWorker void cancel() override; void terminate() override; void on_time(const TimeStamp&) override; + HedgerState state () override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp index 6d4b91fe7..3da53a541 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp @@ -15,4 +15,5 @@ void HedgerWaitingForFirstAckCancelled::terminate() {} void HedgerWaitingForFirstAckCancelled::on_time(const TimeStamp&) {} +HedgerState HedgerWaitingForFirstAckCancelled::state() {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h index 962789e02..6e1c41f0b 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h @@ -13,6 +13,7 @@ class HedgerWaitingForFirstAckCancelled : public IHedgerStateWorker void cancel() override; void terminate() override; void on_time(const TimeStamp&) override; + HedgerState state () override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp index 1af9b51b6..930f0aad1 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp @@ -15,4 +15,5 @@ void HedgerWorkingStateWorker::terminate() {} void HedgerWorkingStateWorker::on_time(const TimeStamp&) {} +HedgerState HedgerWorkingStateWorker::state() {return HedgerState::WORKING;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h index a6ff30cc1..97314e668 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h @@ -13,6 +13,7 @@ class HedgerWorkingStateWorker : public IHedgerStateWorker void cancel() override; void terminate() override; void on_time(const TimeStamp&) override; + HedgerState state () override; }; }} \ No newline at end of file From 8d579c2f0bb62adc46c20aa457cdbd0105076d9a Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 31 Oct 2017 15:47:51 -0400 Subject: [PATCH 2/6] IHedgerStateWorker get a build_once --- .../sparkd/spreader/SingleFillHedger.cpp | 9 +++++- src/server/sparkd/spreader/SingleFillHedger.h | 5 ++-- .../spreader/hedger/IHedgerStateWorker.h | 2 ++ .../hedger_states/HedgerEndStateWorker.cpp | 1 + .../hedger_states/HedgerEndStateWorker.h | 6 +++- .../hedger_states/HedgerStartStateWorker.cpp | 29 +++++++++++++++---- .../hedger_states/HedgerStartStateWorker.h | 4 +++ .../HedgerWaitingForCancelAckStateWorker.cpp | 1 + .../HedgerWaitingForCancelAckStateWorker.h | 4 +++ .../HedgerWaitingForFirstAck.cpp | 1 + .../hedger_states/HedgerWaitingForFirstAck.h | 4 +++ .../HedgerWaitingForFirstAckCancelled.cpp | 1 + .../HedgerWaitingForFirstAckCancelled.h | 4 +++ .../HedgerWorkingStateWorker.cpp | 1 + .../hedger_states/HedgerWorkingStateWorker.h | 4 +++ 15 files changed, 66 insertions(+), 10 deletions(-) diff --git a/src/server/sparkd/spreader/SingleFillHedger.cpp b/src/server/sparkd/spreader/SingleFillHedger.cpp index 28cd734f2..f9fc17a88 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.cpp +++ b/src/server/sparkd/spreader/SingleFillHedger.cpp @@ -4,6 +4,7 @@ #include "SpreaderUtils.h" #include "SpreaderOrderUpdateMessage.h" #include "server/sparkd/spreader/hedger/hedger_states/HedgerState.h" +#include "server/sparkd/spreader/LegPropertyData.h" namespace bts { namespace orderman { @@ -20,7 +21,8 @@ SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager, _order (order), _price_quantity_state(hedge_price, hedge_quantity, hedge_side), _curr_state_worker (nullptr) -{ +{ + LOG(OrderMan,Diag,"SingleFillHedger cons, sec {} price {} quantity {} order_key {}", leg_property_data.security_key(), hedge_price.value(), hedge_quantity.value(), order.order_key().value()); } bool SingleFillHedger::is_active_order() const { @@ -58,4 +60,9 @@ void SingleFillHedger::on_time (const bts::TimeStamp& ts) { _curr_state_worker->on_time (ts); } +void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK() {} +void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED () {} +void SingleFillHedger::transform_to_WORKING() {} +void SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK() {} +void SingleFillHedger::transform_to_END() {} }} diff --git a/src/server/sparkd/spreader/SingleFillHedger.h b/src/server/sparkd/spreader/SingleFillHedger.h index a94737d07..c0cae48c4 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.h +++ b/src/server/sparkd/spreader/SingleFillHedger.h @@ -28,9 +28,9 @@ private: private: void transform_to_WAITING_FOR_FIRST_ACK(); void transform_to_WAITING_FOR_FIRST_ACK_CANCELLED (); - void _transform_to_WORKING(); + void transform_to_WORKING(); void transform_to_WAITING_FOR_CANCEL_ACK(); - void transform_to_END(); + void transform_to_END(); public: SingleFillHedger(ISpreaderManager& spreader_manager, const LegPropertyData& leg_property_data, @@ -64,6 +64,7 @@ public: void terminate (); // on the engine infrastructure time void on_time(const bts::TimeStamp&); + friend HedgerStartStateWorker; }; }} diff --git a/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h b/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h index b4c37ec24..7b2812319 100644 --- a/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h +++ b/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h @@ -8,9 +8,11 @@ namespace bts { namespace orderman { class SpreaderOrderUpdateMessage; class Book; +class SingleFillHedger; class IHedgerStateWorker { public: + virtual void build_once (SingleFillHedger* hedger) = 0; // called once and only once, before any other calls. virtual void init () = 0; // called only when this hedger's order is updated diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp index 27074ed13..b88cc8243 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp @@ -5,6 +5,7 @@ namespace bts{ namespace orderman{ +void HedgerEndStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerEndStateWorker::init() {} void HedgerEndStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h index afabc297c..a26adf886 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h @@ -4,9 +4,13 @@ namespace bts{ namespace orderman{ - +class SingleFillHedger; class HedgerEndStateWorker : public IHedgerStateWorker { +private: + SingleFillHedger* _hedger; +public: + void build_once (SingleFillHedger* hedger) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override; diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp index 0f0103398..52b7c77a8 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp @@ -1,21 +1,38 @@ #include "server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h" #include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" #include "server/sparkd/orderman/md/Book.h" +#include "server/sparkd/spreader/SingleFillHedger.h" namespace bts{ namespace orderman{ +void HedgerStartStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerStartStateWorker::init() -{} +{ + LOG(OrderMan, Diag, "HedgerStartStateWorker::init order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_WAITING_FOR_FIRST_ACK (); +} void HedgerStartStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "Illegal operation {START,on_order_update}"); +} void HedgerStartStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) -{} +{ + // market data will not be sent until out of start. + bts_assert_msg (false, "Illegal operation {START,on_book}"); +} void HedgerStartStateWorker::cancel() -{} +{ + LOG(OrderMan, Diag, "HedgerStartStateWorker::cancel order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_END (); +} void HedgerStartStateWorker::terminate() -{} +{ + LOG(OrderMan, Diag, "HedgerStartStateWorker::terminate order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_END (); +} void HedgerStartStateWorker::on_time(const TimeStamp&) -{} +{ +} HedgerState HedgerStartStateWorker::state() {return HedgerState::START;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h index 7d9a6fa3b..59dac9832 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h @@ -7,6 +7,10 @@ namespace orderman{ class HedgerStartStateWorker : public IHedgerStateWorker { +private: + SingleFillHedger* _hedger; +public: + void build_once (SingleFillHedger* hedger) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override; diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp index e05045eee..c638fcd9f 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp @@ -3,6 +3,7 @@ namespace bts{ namespace orderman{ +void HedgerWaitingForCancelAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForCancelAckStateWorker::init() {} void HedgerWaitingForCancelAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h index a9673ac43..b84b36f2f 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h @@ -7,6 +7,10 @@ namespace orderman{ class HedgerWaitingForCancelAckStateWorker : public IHedgerStateWorker { +private: + SingleFillHedger* _hedger; +public: + void build_once (SingleFillHedger* hedger) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override; diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp index 486759ca3..38682f3da 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp @@ -3,6 +3,7 @@ namespace bts{ namespace orderman{ +void HedgerWaitingForFirstAck::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForFirstAck::init() {} void HedgerWaitingForFirstAck::on_order_update(const SpreaderOrderUpdateMessage&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h index 5c46d6789..10ed218cc 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h @@ -7,6 +7,10 @@ namespace orderman{ class HedgerWaitingForFirstAck : public IHedgerStateWorker { +private: + SingleFillHedger* _hedger; +public: + void build_once (SingleFillHedger* hedger) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override; diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp index 3da53a541..a792c94a3 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp @@ -3,6 +3,7 @@ namespace bts{ namespace orderman{ +void HedgerWaitingForFirstAckCancelled::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForFirstAckCancelled::init() {} void HedgerWaitingForFirstAckCancelled::on_order_update(const SpreaderOrderUpdateMessage&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h index 6e1c41f0b..063e0bbad 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h @@ -7,6 +7,10 @@ namespace orderman{ class HedgerWaitingForFirstAckCancelled : public IHedgerStateWorker { +private: + SingleFillHedger* _hedger; +public: + void build_once (SingleFillHedger* hedger) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override; diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp index 930f0aad1..580c24c47 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp @@ -3,6 +3,7 @@ namespace bts{ namespace orderman{ +void HedgerWorkingStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWorkingStateWorker::init() {} void HedgerWorkingStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h index 97314e668..be17f8229 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h @@ -7,6 +7,10 @@ namespace orderman{ class HedgerWorkingStateWorker : public IHedgerStateWorker { +private: + SingleFillHedger* _hedger; +public: + void build_once (SingleFillHedger* hedger) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; void on_book (bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book) override; From 1c66f1c6f338dd158901c4add8983fb1735b98e0 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 31 Oct 2017 17:35:23 -0400 Subject: [PATCH 3/6] Spark-268 more work --- src/server/sparkd/CMakeDeps.cmake | 2 +- .../sparkd/spreader/SingleFillHedger.cpp | 48 +++++++++++++++++-- src/server/sparkd/spreader/SingleFillHedger.h | 18 ++++++- .../hedger_states/HedgerStartStateWorker.cpp | 2 + .../HedgerWaitingForFirstAck.cpp | 20 -------- .../HedgerWaitingForFirstAckCancelled.cpp | 20 -------- ...WaitingForFirstAckCancelledStateWorker.cpp | 20 ++++++++ ...rWaitingForFirstAckCancelledStateWorker.h} | 2 +- .../HedgerWaitingForFirstAckStateWorker.cpp | 31 ++++++++++++ ... => HedgerWaitingForFirstAckStateWorker.h} | 2 +- 10 files changed, 115 insertions(+), 50 deletions(-) delete mode 100644 src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp delete mode 100644 src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp create mode 100644 src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp rename src/server/sparkd/spreader/hedger/hedger_states/{HedgerWaitingForFirstAckCancelled.h => HedgerWaitingForFirstAckCancelledStateWorker.h} (87%) create mode 100644 src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp rename src/server/sparkd/spreader/hedger/hedger_states/{HedgerWaitingForFirstAck.h => HedgerWaitingForFirstAckStateWorker.h} (89%) diff --git a/src/server/sparkd/CMakeDeps.cmake b/src/server/sparkd/CMakeDeps.cmake index f480a7616..0460591f5 100644 --- a/src/server/sparkd/CMakeDeps.cmake +++ b/src/server/sparkd/CMakeDeps.cmake @@ -1 +1 @@ -set(sources ;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/Application.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/Market.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;orderman/components/FillRecorder.cpp;orderman/components/Gateway.cpp;orderman/components/MDSource.cpp;orderman/components/NativeOrderMan.cpp;orderman/components/OrderRecorder.cpp;orderman/components/SpreaderOrderMan.cpp;orderman/events/ExecutionReport.cpp;orderman/events/NativeOrderStateChange.cpp;orderman/events/SpreaderOrderStateChange.cpp;orderman/events/TimeChange.cpp;orderman/native_orders/NativeOrder.cpp;orderman/native_orders/NativeOrderBuilder.cpp;orderman/native_orders/NativeOrderFactory.cpp;orderman/persistence/FillDB.cpp;orderman/persistence/OrderDB.cpp;orderman/persistence/gen_order_id.cpp;orderman/service/OrderServiceServer.cpp;orderman/spreader_orders/SpreaderOrder.cpp;orderman/spreader_orders/SpreaderOrderBase.cpp;orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.cpp;orderman/utils/fix_order_codec.cpp;orderman/utils/orderman_utils.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;risk_limits/IRiskLimitObserver.cpp;risk_limits/RiskLimitManager.cpp;risk_limits/RiskLimiter.cpp;risk_limits/SharedRiskLimiter.cpp;risk_limits/SymbolKey.cpp;risk_limits/tests/RiskLimitsTests.cpp;securities/SecurityDB.cpp;spreader/QuoteLegPriceQuantityState.cpp;spreader/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp) \ No newline at end of file +set(sources ;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/Application.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/Market.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;orderman/components/FillRecorder.cpp;orderman/components/Gateway.cpp;orderman/components/MDSource.cpp;orderman/components/NativeOrderMan.cpp;orderman/components/OrderRecorder.cpp;orderman/components/SpreaderOrderMan.cpp;orderman/events/ExecutionReport.cpp;orderman/events/NativeOrderStateChange.cpp;orderman/events/SpreaderOrderStateChange.cpp;orderman/events/TimeChange.cpp;orderman/native_orders/NativeOrder.cpp;orderman/native_orders/NativeOrderBuilder.cpp;orderman/native_orders/NativeOrderFactory.cpp;orderman/persistence/FillDB.cpp;orderman/persistence/OrderDB.cpp;orderman/persistence/gen_order_id.cpp;orderman/service/OrderServiceServer.cpp;orderman/spreader_orders/SpreaderOrder.cpp;orderman/spreader_orders/SpreaderOrderBase.cpp;orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.cpp;orderman/utils/fix_order_codec.cpp;orderman/utils/orderman_utils.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;risk_limits/IRiskLimitObserver.cpp;risk_limits/RiskLimitManager.cpp;risk_limits/RiskLimiter.cpp;risk_limits/SharedRiskLimiter.cpp;risk_limits/SymbolKey.cpp;risk_limits/tests/RiskLimitsTests.cpp;securities/SecurityDB.cpp;spreader/QuoteLegPriceQuantityState.cpp;spreader/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp) \ No newline at end of file diff --git a/src/server/sparkd/spreader/SingleFillHedger.cpp b/src/server/sparkd/spreader/SingleFillHedger.cpp index f9fc17a88..49f7ea19c 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.cpp +++ b/src/server/sparkd/spreader/SingleFillHedger.cpp @@ -23,6 +23,7 @@ SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager, _curr_state_worker (nullptr) { LOG(OrderMan,Diag,"SingleFillHedger cons, sec {} price {} quantity {} order_key {}", leg_property_data.security_key(), hedge_price.value(), hedge_quantity.value(), order.order_key().value()); + transform_to_START (); } bool SingleFillHedger::is_active_order() const { @@ -60,9 +61,46 @@ void SingleFillHedger::on_time (const bts::TimeStamp& ts) { _curr_state_worker->on_time (ts); } -void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK() {} -void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED () {} -void SingleFillHedger::transform_to_WORKING() {} -void SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK() {} -void SingleFillHedger::transform_to_END() {} +void SingleFillHedger::transform_to_START() +{ + bts_assert (_curr_state_worker == nullptr); + LOG(OrderMan, Diag, "SingleFillHedger::transform_to_START order_key {}", _order.order_key().value()); + _curr_state_worker = &_start_state_worker; + _curr_state_worker->build_once (this); +} +void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK() +{ + bts_assert (_curr_state_worker->state() == HedgerState::START); + LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK order_key {}", _order.order_key().value()); + _curr_state_worker = &_waiting_for_first_ack_state_worker; + _curr_state_worker->build_once (this); +} +void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED () +{ + bts_assert (_curr_state_worker->state() == HedgerState::WAITING_FOR_FIRST_ACK); + LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED order_key {}", _order.order_key().value()); + _curr_state_worker = &_waiting_for_first_ack_cancelled_state_worker; + _curr_state_worker->build_once (this); +} +void SingleFillHedger::transform_to_WORKING() +{ + bts_assert (_curr_state_worker->state() == HedgerState::WAITING_FOR_FIRST_ACK); + LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WORKING order_key {}", _order.order_key().value()); + _curr_state_worker = &_working_state_worker; + _curr_state_worker->build_once (this); +} +void SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK() +{ + bts_assert (_curr_state_worker->state() == HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED || _curr_state_worker->state() == HedgerState::WORKING); + LOG(OrderMan, Diag, "SingleFillHedger::transform_to_WAITING_FOR_CANCEL_ACK order_key {}", _order.order_key().value()); + _curr_state_worker = &_waiting_for_cancel_ack_state_worker; + _curr_state_worker->build_once (this); +} +void SingleFillHedger::transform_to_END() +{ + bts_assert (_curr_state_worker->state() != HedgerState::END); + LOG(OrderMan, Diag, "SingleFillHedger::transform_to_END order_key {}", _order.order_key().value()); + _curr_state_worker = &_end_state_worker; + _curr_state_worker->build_once (this); +} }} diff --git a/src/server/sparkd/spreader/SingleFillHedger.h b/src/server/sparkd/spreader/SingleFillHedger.h index c0cae48c4..b25c02676 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.h +++ b/src/server/sparkd/spreader/SingleFillHedger.h @@ -7,8 +7,12 @@ #include "server/sparkd/orderman/utils/orderman_utils.h" #include "server/sparkd/spreader/hedger/HedgePriceQuantityState.h" #include "server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h" -#include "server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h" #include "server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h" +#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h" +#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h" +#include "server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h" +#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h" +#include "server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h" namespace bts { namespace orderman { @@ -24,8 +28,13 @@ private: HedgePriceQuantityState _price_quantity_state; IHedgerStateWorker* _curr_state_worker; HedgerStartStateWorker _start_state_worker; - HedgerEndStateWorker _end_state_worker; + HedgerWaitingForFirstAckStateWorker _waiting_for_first_ack_state_worker; + HedgerWaitingForFirstAckCancelledStateWorker _waiting_for_first_ack_cancelled_state_worker; + HedgerWorkingStateWorker _working_state_worker; + HedgerWaitingForCancelAckStateWorker _waiting_for_cancel_ack_state_worker; + HedgerEndStateWorker _end_state_worker; private: + void transform_to_START(); void transform_to_WAITING_FOR_FIRST_ACK(); void transform_to_WAITING_FOR_FIRST_ACK_CANCELLED (); void transform_to_WORKING(); @@ -65,6 +74,11 @@ public: // on the engine infrastructure time void on_time(const bts::TimeStamp&); friend HedgerStartStateWorker; + friend HedgerWaitingForFirstAckStateWorker; + friend HedgerWaitingForFirstAckCancelledStateWorker; + friend HedgerWorkingStateWorker; + friend HedgerWaitingForCancelAckStateWorker; + friend HedgerEndStateWorker; }; }} diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp index 52b7c77a8..da8da36df 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp @@ -10,6 +10,8 @@ void HedgerStartStateWorker::build_once (SingleFillHedger* hedger) {_hedger = he void HedgerStartStateWorker::init() { LOG(OrderMan, Diag, "HedgerStartStateWorker::init order_key {}", _hedger->_order.order_key().value()); + // this is the only place from where the hedger sends the order + _hedger->_order.create(bts::orderman::NullTickToTradeCorID, _hedger->_price_quantity_state.out_price(), _hedger->_price_quantity_state.target_quantity()); _hedger->transform_to_WAITING_FOR_FIRST_ACK (); } void HedgerStartStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp deleted file mode 100644 index 38682f3da..000000000 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h" - -namespace bts{ -namespace orderman{ - -void HedgerWaitingForFirstAck::build_once (SingleFillHedger* hedger) {_hedger = hedger;} -void HedgerWaitingForFirstAck::init() -{} -void HedgerWaitingForFirstAck::on_order_update(const SpreaderOrderUpdateMessage&) -{} -void HedgerWaitingForFirstAck::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) -{} -void HedgerWaitingForFirstAck::cancel() -{} -void HedgerWaitingForFirstAck::terminate() -{} -void HedgerWaitingForFirstAck::on_time(const TimeStamp&) -{} -HedgerState HedgerWaitingForFirstAck::state() {return HedgerState::WAITING_FOR_FIRST_ACK;} -}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp deleted file mode 100644 index a792c94a3..000000000 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h" - -namespace bts{ -namespace orderman{ - -void HedgerWaitingForFirstAckCancelled::build_once (SingleFillHedger* hedger) {_hedger = hedger;} -void HedgerWaitingForFirstAckCancelled::init() -{} -void HedgerWaitingForFirstAckCancelled::on_order_update(const SpreaderOrderUpdateMessage&) -{} -void HedgerWaitingForFirstAckCancelled::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) -{} -void HedgerWaitingForFirstAckCancelled::cancel() -{} -void HedgerWaitingForFirstAckCancelled::terminate() -{} -void HedgerWaitingForFirstAckCancelled::on_time(const TimeStamp&) -{} -HedgerState HedgerWaitingForFirstAckCancelled::state() {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;} -}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp new file mode 100644 index 000000000..3b131c37e --- /dev/null +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp @@ -0,0 +1,20 @@ +#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h" + +namespace bts{ +namespace orderman{ + +void HedgerWaitingForFirstAckCancelledStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} +void HedgerWaitingForFirstAckCancelledStateWorker::init() +{} +void HedgerWaitingForFirstAckCancelledStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) +{} +void HedgerWaitingForFirstAckCancelledStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) +{} +void HedgerWaitingForFirstAckCancelledStateWorker::cancel() +{} +void HedgerWaitingForFirstAckCancelledStateWorker::terminate() +{} +void HedgerWaitingForFirstAckCancelledStateWorker::on_time(const TimeStamp&) +{} +HedgerState HedgerWaitingForFirstAckCancelledStateWorker::state() {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;} +}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h similarity index 87% rename from src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h rename to src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h index 063e0bbad..6320f71fd 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h @@ -5,7 +5,7 @@ namespace bts{ namespace orderman{ -class HedgerWaitingForFirstAckCancelled : public IHedgerStateWorker +class HedgerWaitingForFirstAckCancelledStateWorker : public IHedgerStateWorker { private: SingleFillHedger* _hedger; diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp new file mode 100644 index 000000000..ab27321a0 --- /dev/null +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp @@ -0,0 +1,31 @@ +#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h" +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" +#include "server/sparkd/spreader/SingleFillHedger.h" +namespace bts{ +namespace orderman{ + +void HedgerWaitingForFirstAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} +void HedgerWaitingForFirstAckStateWorker::init() +{ + bts_assert_msg (false, "Illegal operation {WAITING_FOR_FIRST_ACK,init}"); +} +void HedgerWaitingForFirstAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) +{ + bts_assert (order_update.acknowledged()); +} +void HedgerWaitingForFirstAckStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) +{} +void HedgerWaitingForFirstAckStateWorker::cancel() +{ + LOG(OrderMan, Diag, "HedgerWaitingForFirstAckStateWorker::cancel order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_WAITING_FOR_FIRST_ACK_CANCELLED (); +} +void HedgerWaitingForFirstAckStateWorker::terminate() +{ + LOG(OrderMan, Diag, "HedgerWaitingForFirstAckStateWorker::terminate order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_END (); +} +void HedgerWaitingForFirstAckStateWorker::on_time(const TimeStamp&) +{} +HedgerState HedgerWaitingForFirstAckStateWorker::state() {return HedgerState::WAITING_FOR_FIRST_ACK;} +}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h similarity index 89% rename from src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h rename to src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h index 10ed218cc..04b5fcdff 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h @@ -5,7 +5,7 @@ namespace bts{ namespace orderman{ -class HedgerWaitingForFirstAck : public IHedgerStateWorker +class HedgerWaitingForFirstAckStateWorker : public IHedgerStateWorker { private: SingleFillHedger* _hedger; From e02d22eeaddbf7fe671707b1e8f3efb4be13e83c Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 31 Oct 2017 23:35:55 -0400 Subject: [PATCH 4/6] Spark-268, 2 more state handlers for Hedger --- ...WaitingForFirstAckCancelledStateWorker.cpp | 31 ++++++++++++++++--- .../HedgerWaitingForFirstAckStateWorker.cpp | 6 ++++ 2 files changed, 32 insertions(+), 5 deletions(-) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp index 3b131c37e..9285c8f4d 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp @@ -1,19 +1,40 @@ #include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h" +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" +#include "server/sparkd/spreader/SingleFillHedger.h" namespace bts{ namespace orderman{ void HedgerWaitingForFirstAckCancelledStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForFirstAckCancelledStateWorker::init() -{} -void HedgerWaitingForFirstAckCancelledStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "Illegal operation {HedgerWaitingForFirstAckCancelledStateWorker,init}"); +} +void HedgerWaitingForFirstAckCancelledStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) +{ + bts_assert (order_update.acknowledged()); + _hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity()); + if (order_update.terminal_status()) + _hedger->transform_to_END (); + else + { + // this means the first ack is here and we should + // be able to cancel it now + _hedger->_order.cancel(); + _hedger->transform_to_WAITING_FOR_CANCEL_ACK (); + } +} void HedgerWaitingForFirstAckCancelledStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) {} void HedgerWaitingForFirstAckCancelledStateWorker::cancel() -{} +{ + // already been cancelled +} void HedgerWaitingForFirstAckCancelledStateWorker::terminate() -{} +{ + LOG(OrderMan, Diag, "HedgerWaitingForFirstAckCancelledStateWorker::terminate order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_END (); +} void HedgerWaitingForFirstAckCancelledStateWorker::on_time(const TimeStamp&) {} HedgerState HedgerWaitingForFirstAckCancelledStateWorker::state() {return HedgerState::WAITING_FOR_FIRST_ACK_CANCELLED;} diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp index ab27321a0..fa10a2b08 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp @@ -12,6 +12,12 @@ void HedgerWaitingForFirstAckStateWorker::init() void HedgerWaitingForFirstAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) { bts_assert (order_update.acknowledged()); + _hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity()); + if (order_update.terminal_status()) + _hedger->transform_to_END (); + else + // this means the first ack + _hedger->transform_to_WORKING (); } void HedgerWaitingForFirstAckStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) {} From 394852a4929d36b3466d606d9184112f85705b8d Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 1 Nov 2017 07:39:27 -0400 Subject: [PATCH 5/6] hedger states --- .../hedger_states/HedgerEndStateWorker.cpp | 4 ++- .../hedger_states/HedgerEndStateWorker.h | 2 ++ .../HedgerWaitingForCancelAckStateWorker.cpp | 28 +++++++++++---- .../HedgerWorkingStateWorker.cpp | 35 ++++++++++++++----- 4 files changed, 54 insertions(+), 15 deletions(-) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp index b88cc8243..01787d893 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp @@ -7,7 +7,9 @@ namespace orderman{ void HedgerEndStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerEndStateWorker::init() -{} +{ + bts_assert_msg (false, "Illegal operation {HedgerEndStateWorker,init}"); +} void HedgerEndStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) {} void HedgerEndStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h index a26adf886..e60ddf1b5 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h @@ -5,6 +5,8 @@ namespace bts{ namespace orderman{ class SingleFillHedger; +// at some point we should have a CleanEnd and an UncleanEnd, where +// in the former we know that the order has reached its terminal state class HedgerEndStateWorker : public IHedgerStateWorker { private: diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp index c638fcd9f..880b4a731 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp @@ -1,20 +1,36 @@ #include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h" +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" +#include "server/sparkd/spreader/SingleFillHedger.h" namespace bts{ namespace orderman{ void HedgerWaitingForCancelAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForCancelAckStateWorker::init() -{} -void HedgerWaitingForCancelAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "Illegal operation {HedgerWaitingForCancelAckStateWorker,init}"); +} +void HedgerWaitingForCancelAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) +{ + bts_assert (order_update.acknowledged()); + _hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity()); + if (order_update.terminal_status()) + _hedger->transform_to_END (); +} void HedgerWaitingForCancelAckStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) {} void HedgerWaitingForCancelAckStateWorker::cancel() -{} +{ + LOG(OrderMan, Diag, "HedgerWaitingForCancelAckStateWorker::cancel order_key {}, already waiting for cancel", _hedger->_order.order_key().value()); +} void HedgerWaitingForCancelAckStateWorker::terminate() -{} +{ + LOG(OrderMan, Diag, "HedgerWaitingForCancelAckStateWorker::terminate order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_END (); +} void HedgerWaitingForCancelAckStateWorker::on_time(const TimeStamp&) -{} +{ + // TODO: timeout +} HedgerState HedgerWaitingForCancelAckStateWorker::state() {return HedgerState::WAITING_FOR_CANCEL_ACK;} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp index 580c24c47..b084f0c87 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp @@ -1,20 +1,39 @@ #include "server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h" - +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" +#include "server/sparkd/spreader/SingleFillHedger.h" namespace bts{ namespace orderman{ void HedgerWorkingStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWorkingStateWorker::init() -{} -void HedgerWorkingStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "Illegal operation {HedgerWorkingStateWorker,init}"); +} +void HedgerWorkingStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) +{ + bts_assert (order_update.acknowledged()); + _hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity()); + if (order_update.terminal_status()) + _hedger->transform_to_END (); +} void HedgerWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) -{} +{ + /// TODO:post hedging +} void HedgerWorkingStateWorker::cancel() -{} +{ + LOG(OrderMan, Diag, "HedgerWorkingStateWorker::cancel order_key {}", _hedger->_order.order_key().value()); + _hedger->_order.cancel(); + _hedger->transform_to_WAITING_FOR_CANCEL_ACK (); +} void HedgerWorkingStateWorker::terminate() -{} +{ + LOG(OrderMan, Diag, "HedgerWorkingStateWorker::terminate order_key {}", _hedger->_order.order_key().value()); + _hedger->transform_to_END (); +} void HedgerWorkingStateWorker::on_time(const TimeStamp&) -{} +{ + /// TODO:post hedging +} HedgerState HedgerWorkingStateWorker::state() {return HedgerState::WORKING;} }} \ No newline at end of file From 54c61607959a0b85034964d38379157027b17df8 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 1 Nov 2017 10:18:44 -0400 Subject: [PATCH 6/6] SPARK-268, hedger state handlers --- .../hedger/hedger_states/HedgerEndStateWorker.cpp | 2 +- .../hedger/hedger_states/HedgerStartStateWorker.cpp | 10 +++++----- .../HedgerWaitingForCancelAckStateWorker.cpp | 3 ++- .../HedgerWaitingForFirstAckCancelledStateWorker.cpp | 3 ++- .../HedgerWaitingForFirstAckStateWorker.cpp | 3 ++- .../hedger/hedger_states/HedgerWorkingStateWorker.cpp | 3 ++- 6 files changed, 14 insertions(+), 10 deletions(-) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp index 01787d893..42ace4e20 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp @@ -8,7 +8,7 @@ namespace orderman{ void HedgerEndStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerEndStateWorker::init() { - bts_assert_msg (false, "Illegal operation {HedgerEndStateWorker,init}"); + bts_assert_msg (false, "HedgerEndStateWorker::init illegal operation"); } void HedgerEndStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) {} diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp index da8da36df..e78ed8b19 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp @@ -9,28 +9,28 @@ namespace orderman{ void HedgerStartStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerStartStateWorker::init() { - LOG(OrderMan, Diag, "HedgerStartStateWorker::init order_key {}", _hedger->_order.order_key().value()); + LOG(OrderMan, Diag, "HedgerStartStateWorker::init order_key {}, placing order", _hedger->_order.order_key().value()); // this is the only place from where the hedger sends the order _hedger->_order.create(bts::orderman::NullTickToTradeCorID, _hedger->_price_quantity_state.out_price(), _hedger->_price_quantity_state.target_quantity()); _hedger->transform_to_WAITING_FOR_FIRST_ACK (); } void HedgerStartStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) { - bts_assert_msg (false, "Illegal operation {START,on_order_update}"); + bts_assert_msg (false, "HedgerStartStateWorker::on_order_update illegal operation"); } void HedgerStartStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) { // market data will not be sent until out of start. - bts_assert_msg (false, "Illegal operation {START,on_book}"); + bts_assert_msg (false, "HedgerStartStateWorker::on_book illegal operation"); } void HedgerStartStateWorker::cancel() { - LOG(OrderMan, Diag, "HedgerStartStateWorker::cancel order_key {}", _hedger->_order.order_key().value()); + LOG(OrderMan, Diag, "HedgerStartStateWorker::cancel order_key {}, going to END state", _hedger->_order.order_key().value()); _hedger->transform_to_END (); } void HedgerStartStateWorker::terminate() { - LOG(OrderMan, Diag, "HedgerStartStateWorker::terminate order_key {}", _hedger->_order.order_key().value()); + LOG(OrderMan, Diag, "HedgerStartStateWorker::terminate order_key {}, going to END state", _hedger->_order.order_key().value()); _hedger->transform_to_END (); } void HedgerStartStateWorker::on_time(const TimeStamp&) diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp index 880b4a731..90cd89a12 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp @@ -8,11 +8,12 @@ namespace orderman{ void HedgerWaitingForCancelAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForCancelAckStateWorker::init() { - bts_assert_msg (false, "Illegal operation {HedgerWaitingForCancelAckStateWorker,init}"); + bts_assert_msg (false, "HedgerWaitingForCancelAckStateWorker::init illegal operation"); } void HedgerWaitingForCancelAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) { bts_assert (order_update.acknowledged()); + LOG(OrderMan, Diag, "HedgerWaitingForCancelAckStateWorker::on_order_update order_key {}", _hedger->_order.order_key().value()); _hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity()); if (order_update.terminal_status()) _hedger->transform_to_END (); diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp index 9285c8f4d..0e13237e4 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp @@ -8,7 +8,7 @@ namespace orderman{ void HedgerWaitingForFirstAckCancelledStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForFirstAckCancelledStateWorker::init() { - bts_assert_msg (false, "Illegal operation {HedgerWaitingForFirstAckCancelledStateWorker,init}"); + bts_assert_msg (false, "HedgerWaitingForFirstAckCancelledStateWorker::init illegal operation"); } void HedgerWaitingForFirstAckCancelledStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) { @@ -28,6 +28,7 @@ void HedgerWaitingForFirstAckCancelledStateWorker::on_book(bts::orderman::TickTo {} void HedgerWaitingForFirstAckCancelledStateWorker::cancel() { + LOG(OrderMan, Diag, "HedgerWaitingForFirstAckCancelledStateWorker::cancel order_key {}, already cancelled", _hedger->_order.order_key().value()); // already been cancelled } void HedgerWaitingForFirstAckCancelledStateWorker::terminate() diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp index fa10a2b08..6334d0f7e 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp @@ -7,11 +7,12 @@ namespace orderman{ void HedgerWaitingForFirstAckStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWaitingForFirstAckStateWorker::init() { - bts_assert_msg (false, "Illegal operation {WAITING_FOR_FIRST_ACK,init}"); + bts_assert_msg (false, "HedgerWaitingForFirstAckStateWorker::init illegal operation"); } void HedgerWaitingForFirstAckStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) { bts_assert (order_update.acknowledged()); + LOG(OrderMan, Diag, "HedgerWaitingForFirstAckStateWorker::on_order_update order_key {}", _hedger->_order.order_key().value()); _hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity()); if (order_update.terminal_status()) _hedger->transform_to_END (); diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp index b084f0c87..0de53bff3 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp @@ -7,11 +7,12 @@ namespace orderman{ void HedgerWorkingStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerWorkingStateWorker::init() { - bts_assert_msg (false, "Illegal operation {HedgerWorkingStateWorker,init}"); + bts_assert_msg (false, "HedgerWorkingStateWorker::init illegal operation"); } void HedgerWorkingStateWorker::on_order_update(const SpreaderOrderUpdateMessage& order_update) { bts_assert (order_update.acknowledged()); + LOG(OrderMan, Diag, "HedgerWorkingStateWorker::on_order_update order_key {}", _hedger->_order.order_key().value()); _hedger->_price_quantity_state.update_fill (order_update.last_update_filled_quantity()); if (order_update.terminal_status()) _hedger->transform_to_END ();