diff --git a/src/server/sparkd/CMakeDeps.cmake b/src/server/sparkd/CMakeDeps.cmake index 331e5408f..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/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.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 185f0d622..49f7ea19c 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.cpp +++ b/src/server/sparkd/spreader/SingleFillHedger.cpp @@ -3,177 +3,104 @@ #include "ISpreaderManager.h" #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 { -SingleFillHedger::SingleFillHedger(ISpreaderManager& , - const LegPropertyData& , - bts::orderman::SpreaderOrderBase::ChildOrder, +SingleFillHedger::SingleFillHedger(ISpreaderManager& spreader_manager, + const LegPropertyData& leg_property_data, + 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), + _spreader_manager(spreader_manager), + _leg_property_data (leg_property_data), + _order (order), _price_quantity_state(hedge_price, hedge_quantity, hedge_side), - _state(HedgerState::START), _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 +{ + 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(); +} +void SingleFillHedger::on_time (const bts::TimeStamp& ts) +{ + _curr_state_worker->on_time (ts); +} +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); } - -/***************************************************************************/ -/*********External Event Handling in WAITING_FOR_FIRST_ACK******************/ -/***************************************************************************/ void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK() { - 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()); + 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::_handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data) +void SingleFillHedger::transform_to_WAITING_FOR_FIRST_ACK_CANCELLED () { - 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(); + 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); } -/***************************************************************************/ -/*******************External Event Handling in WORKING**********************/ -/***************************************************************************/ -void SingleFillHedger::_transform_to_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 + 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::_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); + 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::_handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data) +void SingleFillHedger::transform_to_END() { - if (event_data.external_event == ExternalHedgerEvents::OrderState) - { - const SpreaderOrderUpdateMessage& update_message = *(event_data.order_state); - if (update_message.terminal_status()) - 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); } -/***************************************************************************/ -/*********************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 96e2a89b4..201b56fe2 100644 --- a/src/server/sparkd/spreader/SingleFillHedger.h +++ b/src/server/sparkd/spreader/SingleFillHedger.h @@ -5,9 +5,14 @@ #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" +#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 { @@ -16,137 +21,29 @@ 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; + 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: - /********************External Event Handling in START***********************/ - void _handle_events_in_START(const EventData& event_data); - /*********External Event Handling in WAITING_FOR_FIRST_ACK******************/ +private: + void transform_to_START(); 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_WORKING(); - void _handle_events_in_WORKING(const EventData& event_data); - /*********External Event Handling in WAITING_FOR_CANCEL_ACK******************/ + void transform_to_WAITING_FOR_FIRST_ACK_CANCELLED (); + void transform_to_WORKING(); 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); 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 +54,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,8 +70,15 @@ 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&); + friend HedgerStartStateWorker; + friend HedgerWaitingForFirstAckStateWorker; + friend HedgerWaitingForFirstAckCancelledStateWorker; + friend HedgerWorkingStateWorker; + friend HedgerWaitingForCancelAckStateWorker; + friend HedgerEndStateWorker; }; }} 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..7b2812319 100644 --- a/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h +++ b/src/server/sparkd/spreader/hedger/IHedgerStateWorker.h @@ -2,14 +2,17 @@ #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 { 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 @@ -24,5 +27,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..42ace4e20 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp @@ -5,8 +5,11 @@ namespace bts{ namespace orderman{ +void HedgerEndStateWorker::build_once (SingleFillHedger* hedger) {_hedger = hedger;} void HedgerEndStateWorker::init() -{} +{ + bts_assert_msg (false, "HedgerEndStateWorker::init illegal operation"); +} void HedgerEndStateWorker::on_order_update(const SpreaderOrderUpdateMessage&) {} void HedgerEndStateWorker::on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) @@ -17,4 +20,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..e60ddf1b5 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerEndStateWorker.h @@ -4,15 +4,22 @@ 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: + 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; 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..e78ed8b19 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp @@ -1,20 +1,40 @@ #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 {}, 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, "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, "HedgerStartStateWorker::on_book illegal operation"); +} void HedgerStartStateWorker::cancel() -{} +{ + 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 {}, going to END state", _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 e5fa211f8..59dac9832 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerStartStateWorker.h @@ -7,12 +7,17 @@ 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; 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..90cd89a12 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp @@ -1,18 +1,37 @@ #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, "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 (); +} 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/HedgerWaitingForCancelAckStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h index 4d10da4fd..b84b36f2f 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.h @@ -7,12 +7,17 @@ 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; 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 deleted file mode 100644 index 7186af5c1..000000000 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.cpp +++ /dev/null @@ -1,18 +0,0 @@ -#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h" - -namespace bts{ -namespace orderman{ - -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&) -{} -}} \ 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 6d4b91fe7..000000000 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.cpp +++ /dev/null @@ -1,18 +0,0 @@ -#include "server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h" - -namespace bts{ -namespace orderman{ - -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&) -{} -}} \ 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..0e13237e4 --- /dev/null +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp @@ -0,0 +1,42 @@ +#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() +{ + bts_assert_msg (false, "HedgerWaitingForFirstAckCancelledStateWorker::init illegal operation"); +} +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() +{ + LOG(OrderMan, Diag, "HedgerWaitingForFirstAckCancelledStateWorker::cancel order_key {}, already cancelled", _hedger->_order.order_key().value()); + // 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;} +}} \ 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 66% rename from src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h rename to src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h index 962789e02..6320f71fd 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelled.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.h @@ -5,14 +5,19 @@ namespace bts{ namespace orderman{ -class HedgerWaitingForFirstAckCancelled : public IHedgerStateWorker +class HedgerWaitingForFirstAckCancelledStateWorker : 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; 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/HedgerWaitingForFirstAckStateWorker.cpp b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp new file mode 100644 index 000000000..6334d0f7e --- /dev/null +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp @@ -0,0 +1,38 @@ +#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, "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 (); + else + // this means the first ack + _hedger->transform_to_WORKING (); +} +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 67% rename from src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h rename to src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h index 784c5e8c6..04b5fcdff 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAck.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.h @@ -5,14 +5,19 @@ namespace bts{ namespace orderman{ -class HedgerWaitingForFirstAck : public IHedgerStateWorker +class HedgerWaitingForFirstAckStateWorker : 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; 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..0de53bff3 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp @@ -1,18 +1,40 @@ #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, "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 (); +} 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 diff --git a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h index a6ff30cc1..be17f8229 100644 --- a/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h +++ b/src/server/sparkd/spreader/hedger/hedger_states/HedgerWorkingStateWorker.h @@ -7,12 +7,17 @@ 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; void cancel() override; void terminate() override; void on_time(const TimeStamp&) override; + HedgerState state () override; }; }} \ No newline at end of file