Merge branch 'master' of bitbucket.org:bluetradesys/spark

This commit is contained in:
Pedro Pinto committed 2017-10-13 20:08:08 +00:00
commit fac9569844
9 files changed
+181 -17

No files matched your search

+13
View File
@@ -0,0 +1,13 @@
{
"files.associations": {
"utility": "cpp",
"initializer_list": "cpp",
"list": "cpp",
"type_traits": "cpp",
"vector": "cpp",
"xhash": "cpp",
"xstring": "cpp",
"xutility": "cpp",
"*.ipp": "cpp"
}
}
@@ -1,9 +1,11 @@
#include "SpreaderOrder.h"
#include "lib/logging/logging.h"
#include "lib/utils/PBUtils.h"
#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h"
#include "server/sparkd/orderman/spreader_orders/SpreaderOrderState.h"
#include "server/sparkd/securities/SecurityDB.h"
#include "server/sparkd/spreader/SpreaderUtils.h"
#include "server/sparkd/spreader/LegPropertyData.h"
namespace bts {
namespace orderman {
@@ -12,6 +14,7 @@ struct SpreaderOrder::PImpl
{
PImpl(bool resurrected_arg,
const api::orderman::CreateOrderRequest& create_order_request_arg,
securities::ISecurityDB& db_arg,
OrderKey orderkey_arg,
api::orderman::OrderStatus status,
Price price,
@@ -20,14 +23,16 @@ struct SpreaderOrder::PImpl
:
resurrected (resurrected_arg),
create_order_request (create_order_request_arg),
db (db_arg),
orderkey (orderkey_arg),
status(status),
price(price),
quantity(quantity),
reject_msg(reject_msg)
{}
{}
const bool resurrected;
const api::orderman::CreateOrderRequest create_order_request;
securities::ISecurityDB& db;
const OrderKey orderkey;
api::orderman::OrderStatus status;
Price price;
@@ -40,7 +45,7 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB &db,
api::orderman::OrderState const&os)
:
SpreaderOrderBase(db, f, os),
me(new PImpl(true, api::orderman::CreateOrderRequest(), OrderKey (0), os.order_status(),
me(new PImpl(true, api::orderman::CreateOrderRequest(), db, OrderKey (0), os.order_status(),
Price(os.spreader().price()), Quantity(os.spreader().quantity()), os.reject_msg())),
_state (State::START)
{
@@ -53,7 +58,7 @@ SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db,
api::orderman::CreateOrderRequest const& cor)
:
SpreaderOrderBase(db, f, k, cor),
me(new PImpl(false, cor, k, api::orderman::OS_UNACKNOWLEDGED, Price(cor.spreader().price()),
me(new PImpl(false, cor, db, k, api::orderman::OS_UNACKNOWLEDGED, Price(cor.spreader().price()),
Quantity(cor.spreader().quantity()), std::string(""))),
_state(State::START)
{
@@ -363,7 +368,9 @@ void SpreaderOrder::_init_state()
api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg);
LegPropertyData leg_property_data(leg_idx, leg, st_it->second, leg_order_side);
// order
bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(leg_property_data.security(), leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING);
bts::SecurityKey leg_key = bts::SecurityKey (leg_property_data.security_key());
api::Security const * db_sec = me->db.resolve (leg_key);
bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(*db_sec, leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING);
bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory();
SingleLegQuoter leg_quoter(me_ref, leg_property_data, n_spreader_legs, Price(cor.price()), Quantity(cor.quantity()), child_order);
SpreaderBookkeepingData::LegData leg_data(leg_property_data, leg_quoter, child_order.order_key());
@@ -387,7 +394,9 @@ void SpreaderOrder::_transform_to_WORKING()
for (size_t index = 0; index < _bookkeeping_data->count(); index++)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data(index);
subscribe_to_md (leg_data.leg_property_data.security());
bts::SecurityKey leg_key = bts::SecurityKey (leg_data.leg_property_data.security_key());
api::Security const * db_sec = me->db.resolve (leg_key);
subscribe_to_md (*db_sec);
}
for (size_t index = 0; index < _bookkeeping_data->count(); index++)
{
@@ -496,4 +505,13 @@ void SpreaderOrder::report_state()
me->status, me->price,me->quantity,me->reject_msg.empty() ? nullptr : &me->reject_msg });
}
/*******************************************************************************/
/******************Functions to Help Testing************************************/
SingleLegQuoter& SpreaderOrder::quoter (size_t index)
{
SpreaderBookkeepingData::LegData& leg_data = _bookkeeping_data->get_leg_data (index);
return leg_data.quoter;
}
}}
@@ -6,8 +6,6 @@
#include "lib/sparkproto/SparkProtos.pb.h"
#include "server/sparkd/spreader/SpreaderBookkeepingData.h"
#include "server/sparkd/spreader/ISpreaderManager.h"
#include "server/sparkd/spreader/LegPropertyData.h"
#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h"
namespace bts {
namespace api {namespace orderman {class OrderState; class CreateSpreaderOrder;}}
@@ -80,6 +78,8 @@ public:
// ISpreaderManager members
const orderman::Book& get_book(size_t leg_index) const override;
const LegPropertyData& get_leg_data(size_t leg_index) const override;
State state () const {return _state;} // this is exposed for testing reasons only
SingleLegQuoter& quoter (size_t index);
private:
void _init_state ();
void _transform_to_WAITING_FOR_FIRST_CONNECTION();
@@ -8,10 +8,17 @@
#include "server/sparkd/orderman/native_orders/NativeOrderFactory.h"
#include "lib/api/services/OrderService.pb.h"
#include "server/sparkd/orderman/spreader_orders/SpreaderOrder.h"
#include "lib/utils/datetime.h"
#include "lib/utils/PBUtils.h"
namespace bts {
namespace orderman {
using namespace orderman;
using namespace api;
using namespace spark;
struct MySecDB : public securities::ISecurityDB
{
std::map<SecurityKey,api::Security const*> secs;
@@ -66,7 +73,110 @@ const char *fut2 =
" cfi_code: \"FFIXSX\"\n"
" cme_symbol: \"ES\"\n"
"}\n";
// creates the spreader security here
Security make_spreader_security()
{
auto sec1 = securities::from_str(fut1);
bts_assert(sec1.first);
auto sec2 = securities::from_str(fut2);
bts_assert(sec2.first);
api::orderman::CreateSpreaderOrder r;
ContractLeg leg_1_contract_leg;
*leg_1_contract_leg.mutable_security() = sec1.second;
leg_1_contract_leg.set_quantity(1.0);
leg_1_contract_leg.set_side(api::SIDE_BUY);
leg_1_contract_leg.set_price_multiplier(1.0);
ContractLeg leg_2_contract_leg;
*leg_2_contract_leg.mutable_security() = sec2.second;
leg_2_contract_leg.set_quantity(1.0);
leg_2_contract_leg.set_side(api::SIDE_SELL);
leg_2_contract_leg.set_price_multiplier(1.0);
// putting the legs together
SyntheticContract synth_contract;
synth_contract.set_name("spread_test_1");
synth_contract.set_price_calc(bts::api::SyntheticContract_PriceCalc::SyntheticContract_PriceCalc_diff);
synth_contract.mutable_legs()->Add()->MergeFrom(leg_1_contract_leg);
synth_contract.mutable_legs()->Add()->MergeFrom(leg_2_contract_leg);
// Specification
api::ContractSpecification spec;
spec.set_low_tick(0.25);
spec.set_high_tick(0.25);
Security rv;
rv.set_exchange(api::VENUE_GLBX);
rv.mutable_contract_spec()->MergeFrom(spec);
rv.mutable_synthetic()->MergeFrom(synth_contract);
bts_assert (rv.contract_spec().low_tick() == 0.25);
bts_assert (rv.contract_spec().high_tick() == 0.25);
return rv;
}
ExecutionStrategy create_execution_strategy(uint32_t leg_1_id, uint32_t leg_2_id)
{
// leg 1
QuoteMuteZone leg_1_quotemutezone;
leg_1_quotemutezone.set_outside_ticks(1);
leg_1_quotemutezone.set_inside_ticks(1);
QuoteParams leg_1_quoteparams;
leg_1_quoteparams.mutable_quote_mute_zone()->MergeFrom(leg_1_quotemutezone);
leg_1_quoteparams.set_lean_quantity_ratio (1.0);
LegSpreaderParams leg_1_spreaderparams;
leg_1_spreaderparams.set_price_multiplier(1.0);
leg_1_spreaderparams.set_is_active_quoting(false);
leg_1_spreaderparams.mutable_quote_params()->MergeFrom(leg_1_quoteparams);
// leg 1
QuoteMuteZone leg_2_quotemutezone;
leg_2_quotemutezone.set_outside_ticks(1);
leg_2_quotemutezone.set_inside_ticks(1);
QuoteParams leg_2_quoteparams;
leg_2_quoteparams.mutable_quote_mute_zone()->MergeFrom(leg_2_quotemutezone);
leg_2_quoteparams.set_lean_quantity_ratio (1.0);
LegSpreaderParams leg_2_spreaderparams;
leg_2_spreaderparams.set_price_multiplier(-1.0);
leg_2_spreaderparams.set_is_active_quoting(true);
leg_2_spreaderparams.mutable_quote_params()->MergeFrom(leg_2_quoteparams);
ExecutionStrategy rv;
rv.mutable_leg_params_map()->insert(google::protobuf::MapPair<unsigned int, bts::spark::LegSpreaderParams>(leg_1_id, leg_1_spreaderparams));
rv.mutable_leg_params_map()->insert(google::protobuf::MapPair<unsigned int, bts::spark::LegSpreaderParams>(leg_2_id, leg_2_spreaderparams));
bts_assert (rv.leg_params_map().size() == 2);
return rv;
}
api::orderman::CreateSpreaderOrder create_spreader_order_creation(std::string account_name, std::string operator_id,
Price price, Quantity quantity, api::Side side)
{
Security sec = make_spreader_security();
uint32_t leg_1_id = sec.synthetic().legs(0).security().id();
uint32_t leg_2_id = sec.synthetic().legs(1).security().id();
ExecutionStrategy execution_strategy = create_execution_strategy(leg_1_id, leg_2_id);
api::orderman::CreateSpreaderOrder rv;
rv.set_account_name(account_name);
rv.set_operator_id(operator_id);
rv.set_price(price.value());
rv.set_quantity(quantity.value());
rv.set_side(side);
rv.mutable_security()->MergeFrom (sec);
rv.mutable_execution_strategy()->MergeFrom(execution_strategy);
return rv;
}
api::orderman::CreateOrderRequest make_spreader_order_create_request(api::Side side, Price price, Quantity quantity)
{
api::orderman::CreateOrderRequest result;
*result.mutable_timestamp() = utils::pb::to_timestamp(datetime::now());
result.set_customer_or_firm(api::orderman::COF_FIRM);
result.set_cti_code(api::orderman::CTI_CTI1);
api::orderman::CreateSpreaderOrder create_order = create_spreader_order_creation("BTS", "BTS", price, quantity, side);
result.mutable_spreader()->MergeFrom(create_order);
return result;
}
TEST_CASE ("Spreader Order", "[spreader]")
{
@@ -82,18 +192,28 @@ TEST_CASE ("Spreader Order", "[spreader]")
SECTION("test")
{
api::orderman::CreateOrderRequest req;
SpreaderOrder order (db,factory,OrderKey(1),req);
api::orderman::CreateOrderRequest cor = make_spreader_order_create_request (api::Side::SIDE_BUY, Price (0), Quantity (100));
/*****************Creating the order********************/
SpreaderOrder order (db,factory,OrderKey(1),cor);
auto do_nothing = [] (auto const&) {};
order.init_signals(do_nothing,
do_nothing,
do_nothing,
do_nothing,
do_nothing);
bts_assert (order.state() == SpreaderOrder::State::START);
/*********************Initing the order********************/
order.init ();
bts_assert (order.state() == SpreaderOrder::State::WAITING_FOR_FIRST_CONNECT);
/*********************First on_connect*********************/
order.on_connect ();
bts_assert (order.state() == SpreaderOrder::State::WORKING);
/*********************First on_connect*********************/
SingleLegQuoter& quoter = order.quoter (1);
bts_assert (quoter.state() == SingleLegQuoter::QuoterState::WAITING_FOR_MARKET);
}
}
}}
@@ -170,8 +170,10 @@ void SingleLegQuoter::_handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& e
if (order_udpate_message.terminal_status())
_transform_to_END();
else if (order_udpate_message.has_error())
// TODO, spreader is already checking for this
// and cancelling orders
_transform_to_WAITING_FOR_CANCEL_ACK();
else
else if (order_udpate_message.acknowledged())
{
if (order_udpate_message.status == api::orderman::OS_UNACKNOWLEDGED)
return;
+1 -1
View File
@@ -163,7 +163,7 @@ public:
// called when the hedge order is cancelled, either
// manually or automatically
void cancel_order();
QuoterState get_state() { return _state; }
QuoterState state() { return _state; }
private:
/********************External Event Handling in START***********************/
void _handle_events_in_START(const EventData& event_data);
@@ -43,6 +43,8 @@ public:
{ }
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
+13 -4
View File
@@ -78,14 +78,23 @@ public:
}
bts_assert(false);
}
static bool order_acknowledged (api::orderman::OrderStatus order_status)
{
// any state but that means order is ack'ed
return order_status!=api::orderman::OrderStatus::OS_UNACKNOWLEDGED;
}
static bool order_in_terminal_state(api::orderman::OrderStatus order_status)
{
return order_status == api::orderman::OrderStatus::OS_CANCELED ||
order_status == api::orderman::OrderStatus::OS_DONE ||
order_status == api::orderman::OrderStatus::OS_EXPIRED ||
return order_status == api::orderman::OrderStatus::OS_REJECTED_BY_SPARK ||
order_status == api::orderman::OrderStatus::OS_FILLED ||
order_status == api::orderman::OrderStatus::OS_DONE ||
order_status == api::orderman::OrderStatus::OS_CANCELED ||
order_status == api::orderman::OrderStatus::OS_STOPPED ||
order_status == api::orderman::OrderStatus::OS_REJECTED ||
order_status == api::orderman::OrderStatus::OS_STOPPED;
order_status == api::orderman::OrderStatus::OS_EXPIRED;
}
// CRITICAL PATH
// this traverses the depth of the book, accumulating the quantity,