cleanup and status reporting

This commit is contained in:
Taha Afzal committed 2017-10-14 22:22:05 -04:00
1 parent 573c7a5fe2
commit 16c9c61cbb
5 files changed
+151 -152

No files matched your search

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