This commit is contained in:
Pedro Pinto committed 2017-11-01 21:03:39 +00:00
commit fbeeefe7cf
20 files changed
+356 -319

No files matched your search

+1 -1
View File
@@ -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)
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)
+63 -136
View File
@@ -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&)
{}
}}
+26 -122
View File
@@ -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;
};
}}
@@ -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);
}
};
}}
@@ -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;
};
}}
@@ -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;}
}}
@@ -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;
};
}}
@@ -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;}
}}
@@ -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;
};
}}
@@ -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
};
}}
@@ -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;}
}}
@@ -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;
};
}}
@@ -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&)
{}
}}
@@ -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&)
{}
}}
@@ -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;}
}}
@@ -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;
};
}}
@@ -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;}
}}
@@ -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;
};
}}
@@ -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;}
}}
@@ -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;
};
}}