SPARK-1022

This commit is contained in:
Taha Afzal committed 2018-05-10 10:10:00 -04:00
1 parent b773e801f7
commit f4a2b788ff
9 files changed
+484 -91

No files matched your search

+32
View File
@@ -150,6 +150,38 @@
"/home/bts/spark/": "${workspaceRoot}"
}
},
{
"name": "Limiter Tests",
"type": "cppdbg",
"request": "launch",
"program": "/home/bts/spark/build/ninja_debug/src/server/sparkd/sparkd",
"args": ["test", "[limiter]"],
"stopAtEntry": false,
"cwd": "/home/bts/spark/build/ninja_debug/src/server/sparkd/",
"environment": [],
"externalConsole": true,
"MIMode": "gdb",
"preLaunchTask": "",
"logging": {
"engineLogging": false
},
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "enable pretty-printer",
"ignoreFailures": true
}
],
"pipeTransport": {
"pipeCwd": "${workspaceRoot}",
"pipeProgram": "c:\\program files\\git\\usr\\bin\\ssh.exe",
"pipeArgs": ["bts@sparkvm"],
"debuggerPath": "/usr/bin/gdb"
},
"sourceFileMap": {
"/home/bts/spark/": "${workspaceRoot}"
}
},
{
"name": "MD Tests",
"type": "cppdbg",
+44 -13
View File
@@ -95,6 +95,14 @@ public:
}
return nullptr;
}
static const bts::api::admin::BTSAccount* find_account (const bts::api::admin::AdminData& data, int id){
for(int i=0; i<data.accounts_size(); i++){
const bts::api::admin::BTSAccount& acct = data.accounts(i);
if(id == acct.id())
return &acct;
}
return nullptr;
}
static int find_max_acct_id (bts::api::admin::AdminData& data){
int rv = 0;
for(int i=0; i<data.accounts_size(); i++){
@@ -169,7 +177,7 @@ public:
out_accounts.push_back(account_ptr);
}
}
static std::map<int,bool> accounts_map(bts::api::admin::AdminData& admin_data){
static std::map<int,bool> accounts_map(const bts::api::admin::AdminData& admin_data){
std::map<int,bool> rv;
for(int i=0; i<admin_data.accounts_size(); i++)
rv.insert(std::pair<int,bool>(admin_data.accounts(i).id(),true));
@@ -338,6 +346,14 @@ public:
}
return nullptr;
}
static const bts::api::admin::BTSUserGroup* const find_group (const bts::api::admin::AdminData& data, int id){
for(int i=0; i<data.user_groups_size();i++){
const bts::api::admin::BTSUserGroup& group = data.user_groups(i);
if(id == group.id())
return &group;
}
return nullptr;
}
static bts::api::admin::BTSUserGroup* find_group (bts::api::admin::AdminData& data, const std::string& group_name){
for(int i=0; i<data.user_groups_size();i++){
bts::api::admin::BTSUserGroup* group = data.mutable_user_groups(i);
@@ -417,6 +433,14 @@ public:
}
return nullptr;
}
static const bts::api::admin::BTSUser* const find_user (const bts::api::admin::AdminData& data, int id){
for(int i=0; i<data.users_size(); i++){
const bts::api::admin::BTSUser& user = data.users(i);
if(id == user.id())
return &user;
}
return nullptr;
}
static int find_max_user_id (bts::api::admin::AdminData& data){
int rv = 0;
for(int i=0; i<data.users_size(); i++){
@@ -494,31 +518,33 @@ public:
return std::pair<const bts::api::admin::BTSAccount*, const bts::api::admin::BTSUser*>(nullptr, nullptr);
}
static bts::api::admin::UserAccountPermissions* get_group_user_permissions (bts::api::admin::AdminData& admin_data, int group_id){
bts::api::admin::BTSUserGroup* group = find_group(admin_data, group_id);
static const bts::api::admin::UserAccountPermissions* const get_group_user_permissions (const bts::api::admin::AdminData& admin_data, int group_id){
const bts::api::admin::BTSUserGroup* const group = find_group(admin_data, group_id);
if(group != nullptr){
if (group->has_user_data() && group->user_data().has_account_permissions())
return group->mutable_user_data()->mutable_account_permissions();
return &group->user_data().account_permissions();
if (group->has_parent_group_id())
return get_group_user_permissions(admin_data, group->parent_group_id().id());
}
return nullptr;
}
static bts::api::admin::UserAccountPermissions* get_user_permissions (bts::api::admin::AdminData& admin_data, int user_id){
bts::api::admin::BTSUser* user = find_user(admin_data, user_id);
static const bts::api::admin::UserAccountPermissions* const get_user_permissions (const bts::api::admin::AdminData& admin_data, int user_id){
const bts::api::admin::BTSUser* const user = find_user(admin_data, user_id);
if(user != nullptr){
if (user->has_user_data() && user->user_data().has_account_permissions())
return user->mutable_user_data()->mutable_account_permissions();
return &user->user_data().account_permissions();
else
return get_group_user_permissions(admin_data, user->parent_group_id());
}
return nullptr;
}
static std::map<int, std::vector<int>> user_account_map(bts::api::admin::AdminData& admin_data){
static std::map<int, std::vector<int>> user_account_map(const bts::api::admin::AdminData& admin_data){
std::map<int, std::vector<int>> rv;
for(int i=0; i<admin_data.users_size(); i++){
const bts::api::admin::BTSUser& user = admin_data.users(i);
bts::api::admin::UserAccountPermissions* user_perm_ptr = get_user_permissions(admin_data, user.id());
const bts::api::admin::UserAccountPermissions* const user_perm_ptr = get_user_permissions(admin_data, user.id());
std::vector<int> account_ids;
if (user_perm_ptr != nullptr)
for(auto it=user_perm_ptr->account_permissions().begin(); it!=user_perm_ptr->account_permissions().end(); it++)
@@ -675,10 +701,14 @@ public:
const bts::api::admin::AccountSecurityPositionLimitUnit* rv = nullptr;
for(int i=0; i<account.security_position_limits_size(); i++){
const auto& limit = account.security_position_limits(i);
if (limit.security().exchange()==security.exchange() && security_type(security) == limit.security().security_type()){
if(limit.security().has_security_id() && limit.security().security_id().id()==static_cast<int>(security.id())) //TODO
if(limit.security().has_security_id()){
if (static_cast<uint32_t>(limit.security().security_id().id()) == security.id()) // fix this
return &limit;
else if (_match_limit_rule_symbol(security.symbol(), limit.security().security_symbol()))
}
else{
if (limit.security().exchange()==security.exchange() &&
security_type(security) == limit.security().security_type() &&
_match_limit_rule_symbol(security.symbol(), limit.security().security_symbol()))
rv = &limit;
}
}
@@ -723,7 +753,8 @@ public:
return api::SecurityType::SECURITYTYPE_SYNTHETIC;
case api::Security::ContractCase::CONTRACT_NOT_SET:
return api::SecurityType::SECURITYTYPE_UNSET;
}
}
return api::SecurityType::SECURITYTYPE_UNSET;
}
};
}}
+1 -1
View File
@@ -42,4 +42,4 @@ target_link_libraries( sparkd
-pthread)
# copy test data
file(COPY jetfix/tests/sample_fix.dat DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test_data)
file(COPY jetfix/tests/sample_fix.dat DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test_data)
+36 -19
View File
@@ -18,6 +18,7 @@ namespace orderman {
class LimitStore{
private:
bts::api::admin::AdminData _admin_data;
const std::map<int, bool> _account_map; // just an easy way to find accounts
const std::map<int, std::vector<int>> _user_account_map;
std::map<uint32_t,SecurityLimitTree> _sec_map;
@@ -25,18 +26,20 @@ private:
const bts::api::admin::AccountProductPositionLimitUnit _zero_product_limit; // numeric defaults are 0 in proto3
const bts::api::admin::AccountSecurityPositionLimitUnit _zero_security_limit;
public:
LimitStore(bts::api::admin::AdminData& admin_data,
LimitStore(const bts::api::admin::AdminData& admin_data,
const std::vector<api::Security const*>& securities)
:
_account_map(bts::admin::AdminServiceUtils::accounts_map(admin_data)),
_user_account_map (bts::admin::AdminServiceUtils::user_account_map(admin_data))
_admin_data (admin_data),
_account_map(bts::admin::AdminServiceUtils::accounts_map(_admin_data)),
_user_account_map (bts::admin::AdminServiceUtils::user_account_map(_admin_data))
{
for(auto it=securities.begin(); it!=securities.end(); it++){
const api::Security& security = *(*it);
ProductLimitTree& product_tree = _add_or_get_product_entry(security, admin_data);
_sec_map.insert(std::pair<uint32_t,SecurityLimitTree>(security.id(),SecurityLimitTree(security, product_tree, admin_data, _zero_security_limit)));
ProductLimitTree& product_tree = _add_or_get_product_entry(security, _admin_data);
_sec_map.insert(std::pair<uint32_t,SecurityLimitTree>(security.id(),SecurityLimitTree(security, product_tree, _admin_data, _zero_security_limit)));
}
}
}
// accessors
SecurityLimitTree* find_security(uint32_t sec_id){
auto it = _sec_map.find(sec_id);
if (it == _sec_map.end())
@@ -44,33 +47,46 @@ public:
else
return &it->second;
}
ProductLimitTree* find_product(api::Product& product){
ProductLimitTree* find_product(const api::Product& product){
for(auto it=_prod_map.begin(); it!= _prod_map.end(); it++){
if(product.exchange() == it->product.exchange() && product.type() == it->product.type() && product.symbol() == it->product.symbol())
if(product.exchange() == it->product().exchange() && product.type() == it->product().type() && product.symbol() == it->product().symbol())
return &*it;
}
return nullptr;
}
// this is only used for testing purposes
const SecurityLimitTree::SecurityAccountLimitState* find_security_account_state(AccountID account_id, uint32_t security_id){
SecurityLimitTree* sec_data = find_security(security_id);
if(sec_data != nullptr)
return sec_data->find_account(account_id.value());
return nullptr;
}
const ProductLimitTree::ProductAccountLimitState* find_product_account_state(AccountID account_id, const api::Product& product){
ProductLimitTree* prod_data = find_product(product);
if(prod_data != nullptr)
return prod_data->find_account(account_id.value());
return nullptr;
}
bool has_account(AccountID account_id) {return _account_map.find(account_id.value()) != _account_map.end();}
bool has_security (uint32_t sec_id) {return _sec_map.find(sec_id) != _sec_map.end();}
const bts::api::admin::AdminData& admin_data () {return _admin_data;}
// copies all the security and product positions
// for all the accounts
void copy_positions_from(LimitStore& source){
// copy product positions
for (auto it=_prod_map.begin(); it!= _prod_map.end(); it++){
ProductLimitTree* source_product_limit_tree = source.find_product(it->product);
ProductLimitTree* source_product_limit_tree = source.find_product(it->product());
if(source_product_limit_tree != nullptr)
it->copy_positions_from(*source_product_limit_tree);
}
// copy seucrities
// copy securities
for (auto it=_sec_map.begin(); it!=_sec_map.end(); it++){
SecurityLimitTree* source_security_limit_tree = source.find_security(it->first);
if(source_security_limit_tree != nullptr)
it->second.copy_positions_from(*source_security_limit_tree);
}
}
}
// called from Limiter
void add_position(const api::Security& sec, AccountID account_id, api::Side side, Quantity quantity){
auto it = _sec_map.find(sec.id());
bts_assert(it != _sec_map.end());
@@ -83,9 +99,10 @@ public:
SecurityLimitTree& sec_tree = it->second;
sec_tree.remove_position(account_id, side, quantity);
}
bts::api::admin::AdminServiceOperationResult can_trade(UserID user_id, AccountID account_id){
Limiter::LimiterQueryResult can_trade(UserID user_id,
AccountID account_id) const{
int int_account_id = static_cast<int>(account_id.value()); //TODO
bts::api::admin::AdminServiceOperationResult result; result.set_is_success(true);
Limiter::LimiterQueryResult result; result.ok = true;
auto user_it = _user_account_map.find(user_id.value());
if (user_it != _user_account_map.end()){
std::vector<int> accound_ids = user_it->second;
@@ -93,7 +110,7 @@ public:
if(*it == int_account_id)
return result;
}
result.set_is_success(false);
result.ok = false;
return result;
}
Limiter::LimiterQueryResult can_send_new_order(AccountID account_id,
@@ -119,14 +136,14 @@ public:
else
result.ok = false;
return result;
}
}
private:
// for a security, adds the corresponding product tree.
// if found, returns it
ProductLimitTree& _add_or_get_product_entry(const api::Security& security, const bts::api::admin::AdminData& admin_data){
ProductLimitTree& _add_or_get_product_entry(const api::Security& security,
const bts::api::admin::AdminData& admin_data){
for(auto it=_prod_map.begin(); it!= _prod_map.end(); it++){
const api::Product& product = it->product;
if (bts::admin::AdminServiceUtils::match_product(security,product))
if (bts::admin::AdminServiceUtils::match_product(security, it->product()))
return *it;
}
// not found add it here
+69 -26
View File
@@ -1,42 +1,85 @@
#include "Limiter.h"
#include "LimitStore.h"
#include "lib/domain_model/Security.pb.h"
#include "lib/api/services/AdminService.server.pb.h"
namespace bts {
namespace orderman {
struct Limiter::PImpl {
PImpl() {}
std::vector<api::Security const*> securities;
std::unique_ptr<LimitStore> limit_store;
PImpl()
:
securities(),
limit_store(std::make_unique<LimitStore>(bts::api::admin::AdminData(), securities))
{
}
};
Limiter::Limiter() : me(new PImpl()) {}
Limiter::~Limiter() {}
void Limiter::update(api::admin::AdminData const &) {}
void Limiter::add_securities(std::vector<api::Security const*> const&) {}
void Limiter::add_security(api::Security const &) {}
void Limiter::add(api::Security const &, AccountID, api::Side, Quantity) {}
void Limiter::remove(api::Security const &, AccountID, api::Side, Quantity) {}
Limiter::LimiterQueryResult Limiter::can_trade(UserID, AccountID) const {
return LimiterQueryResult{true, ""};
void Limiter::update(api::admin::AdminData const& admin_data) {
_reset(admin_data);
}
void Limiter::add_securities(std::vector<api::Security const*> const& new_securities){
me->securities.insert(std::end(me->securities), std::begin(new_securities), std::end(new_securities));
_reset(me->limit_store->admin_data());
}
void Limiter::add_security(api::Security const & security) {
me->securities.push_back(&security);
_reset(me->limit_store->admin_data());
}
void Limiter::add(api::Security const &security, AccountID account_id, api::Side side, Quantity quantity){
if (!me->limit_store->has_security(security.id()))
add_security(security);
if (!me->limit_store->has_account(account_id)){
// add a temporary account, so trades can go in there
_add_account_and_reset(account_id);
}
me->limit_store->add_position(security, account_id, side, quantity);
}
void Limiter::remove(api::Security const &security, AccountID account_id, api::Side side, Quantity quantity) {
if (!me->limit_store->has_security(security.id())){
me->securities.push_back(&security);
_reset(me->limit_store->admin_data());
}
if (!me->limit_store->has_account(account_id)){
_add_account_and_reset(account_id);
}
me->limit_store->remove_position(security, account_id, side, quantity);
}
Limiter::LimiterQueryResult Limiter::can_trade(UserID user_id, AccountID account_id) const {
return me->limit_store->can_trade(user_id, account_id);
}
Limiter::LimiterQueryResult Limiter::can_send_new_order(AccountID account_id,
api::Security const & security,
api::Side side,
Quantity quantity) const {
return me->limit_store->can_send_new_order(account_id, security, side, quantity);
}
Limiter::LimiterQueryResult Limiter::can_update_order(AccountID account_id,
api::Security const & security,
api::Side side, Quantity from,
Quantity to) const {
return me->limit_store->can_update_order(account_id, security, side, from, to);
}
void Limiter::_add_account_and_reset(AccountID account_id){
bts::api::admin::AdminData admin_data_catchup = me->limit_store->admin_data();
bts::api::admin::BTSAccount* new_account = admin_data_catchup.mutable_accounts()->Add();
new_account->set_id(account_id.value());
new_account->set_is_active(true);
update(admin_data_catchup);
}
void Limiter::_reset (const bts::api::admin::AdminData& admin_data){
LimitStore* new_store = new LimitStore(admin_data, me->securities);
new_store->copy_positions_from(*me->limit_store);
me->limit_store.reset(new_store);
}
Limiter::LimiterQueryResult Limiter::can_send_new_order(AccountID,
api::Security const &,
api::Side,
Quantity) const {
return LimiterQueryResult{true, ""};
}
Limiter::LimiterQueryResult Limiter::can_update_order(AccountID,
api::Security const &,
api::Side, Quantity,
Quantity) const {
return LimiterQueryResult{true, ""};
}
}
LimitStore& Limiter::limit_store(){
return *me->limit_store;
}
}}
+6 -1
View File
@@ -13,6 +13,7 @@ class AdminData;
namespace bts {
namespace orderman {
class LimitStore;
class Limiter {
public:
Limiter();
@@ -37,9 +38,13 @@ class Limiter {
api::Security const&sec,
api::Side side,
Quantity from, Quantity to) const;
// for testing purposes only
LimitStore& limit_store();
~Limiter();
private:
void _reset (const bts::api::admin::AdminData&);
void _add_account_and_reset(AccountID account_id);
private:
struct PImpl;
std::unique_ptr<PImpl> me;
@@ -15,21 +15,25 @@ namespace orderman{
class ProductLimitTree{
public:
class ProductAccountLimitState{
public:
const int account_id, parent_account_id;
private:
const int _account_id, _parent_account_id;
const bts::api::admin::AccountProductPositionLimitUnit& _limit;
uint32_t _long_pos, _short_pos;
public:
ProductAccountLimitState(int account_id, int parent_account_id, const bts::api::admin::AccountProductPositionLimitUnit& limit)
:
account_id(account_id),
parent_account_id(parent_account_id),
_account_id(account_id),
_parent_account_id(parent_account_id),
_limit(limit),
_long_pos(0),
_short_pos(0)
{}
bool has_parent() const {return parent_account_id != 0;}
{}
// accessors
int account_id() const {return _account_id;}
const bts::api::admin::AccountProductPositionLimitUnit& limit() const {return _limit;}
uint32_t long_pos() const {return _long_pos;}
uint32_t short_pos() const {return _short_pos;}
// mutators
void copy_positions_from(const ProductAccountLimitState& source){
_long_pos=source._long_pos;
_short_pos=source._short_pos;
@@ -46,7 +50,7 @@ public:
else
_short_pos = qty > _short_pos ? 0 : _short_pos - qty;
}
Limiter::LimiterQueryResult can_send_new_order(api::Side side, Quantity quantity){
Limiter::LimiterQueryResult can_send_new_order(api::Side side, Quantity quantity) const{
Limiter::LimiterQueryResult result;
result.ok = ProductLimitTree::can_send_new_order (side, quantity,
_limit.long_position_limit(), _limit.short_position_limit(),
@@ -54,41 +58,41 @@ public:
//TODO: text in result
return result;
}
Limiter::LimiterQueryResult can_update_order(api::Side side, Quantity from, Quantity to){
Limiter::LimiterQueryResult can_update_order(api::Side side, Quantity from, Quantity to) const{
Limiter::LimiterQueryResult result; result.ok = true;
result.ok = ProductLimitTree::can_update_order (side, from, to, _limit.long_position_limit(), _limit.short_position_limit(),
_long_pos, _short_pos);
return result;
}
};
public:
api::Product product;
private:
const api::Product _product;
std::vector<ProductAccountLimitState> _tree;
public:
ProductLimitTree(const api::Product& product, const bts::api::admin::AdminData& admin_data, const bts::api::admin::AccountProductPositionLimitUnit& zero_limit)
:
product (product)
_product (product)
{
for(int i=0; i<admin_data.accounts_size(); i++){
auto account = admin_data.accounts(i);
const bts::api::admin::AccountProductPositionLimitUnit* limit = bts::admin::AdminServiceUtils::find_account_product_position_limit(account, product);
const auto& account = admin_data.accounts(i);
const bts::api::admin::AccountProductPositionLimitUnit* limit = bts::admin::AdminServiceUtils::find_account_product_position_limit(account, _product);
_tree.emplace_back(account.id(), account.has_parent_account_id() ? account.parent_account_id().id() : 0, limit != nullptr ? *limit : zero_limit);
}
}
ProductAccountLimitState* find_account (int account_id){
for(auto it=_tree.begin(); it!=_tree.end(); it++)
if(it->account_id==account_id)
if(it->account_id()==account_id)
return &*it;
return nullptr;
}
void copy_positions_from(ProductLimitTree& source){
for (auto it=_tree.begin(); it!=_tree.end(); it++){
const ProductAccountLimitState* source_account_limit_ptr = source.find_account(it->account_id);
const ProductAccountLimitState* source_account_limit_ptr = source.find_account(it->account_id());
if(source_account_limit_ptr != nullptr)
it->copy_positions_from(*source_account_limit_ptr);
}
}
const api::Product& product() const {return _product;}
// static helpers for limit gating
static bool can_send_new_order(api::Side side, Quantity quantity,
uint32_t long_pos_limit, uint32_t short_pos_limit,
@@ -106,7 +110,7 @@ public:
if (to.value() > from.value()){
uint32_t diff = to.value() - from.value();
if(side == api::Side::SIDE_BUY)
return long_pos + diff < long_pos_limit;
return long_pos + diff < long_pos_limit;
else if(side == api::Side::SIDE_SELL)
return short_pos + diff < short_pos_limit;
else
@@ -14,26 +14,34 @@ namespace bts{
namespace orderman{
class SecurityLimitTree{
private:
public:
class SecurityAccountLimitState{
public:
const int account_id, parent_account_id;
private:
const int _account_id, _parent_account_id;
const bts::api::admin::AccountSecurityPositionLimitUnit& _limit;
const uint32_t _long_pos_limit, _short_pos_limit;
ProductLimitTree::ProductAccountLimitState& _product_limit_state;
uint32_t _long_pos, _short_pos;
public:
SecurityAccountLimitState(int account_id, int parent_account_id, const bts::api::admin::AccountSecurityPositionLimitUnit& limit,
ProductLimitTree::ProductAccountLimitState& product_limit)
ProductLimitTree::ProductAccountLimitState& product_limit)
:
account_id(account_id),
parent_account_id(parent_account_id),
_account_id(account_id),
_parent_account_id(parent_account_id),
_limit(limit),
_long_pos_limit (limit.long_position_limit()),
_short_pos_limit (limit.short_position_limit()),
_product_limit_state(product_limit),
_long_pos(0),
_short_pos(0)
{}
bool has_parent() {return parent_account_id != 0;}
//accessors
int account_id() const {return _account_id;}
// following accessors are only used for test code
const bts::api::admin::AccountSecurityPositionLimitUnit& limit () const {return _limit;}
uint32_t long_pos() const {return _long_pos;}
uint32_t short_pos() const {return _short_pos;}
// mutators
void copy_positions_from(const SecurityAccountLimitState& source){
_long_pos=source._long_pos;
_short_pos=source._short_pos;
@@ -52,18 +60,19 @@ private:
else
_short_pos = qty > _short_pos ? 0 : _short_pos - qty;
}
Limiter::LimiterQueryResult can_send_new_order(api::Side side, Quantity quantity){
Limiter::LimiterQueryResult can_send_new_order(api::Side side, Quantity quantity) const{
Limiter::LimiterQueryResult result;
result.ok = ProductLimitTree::can_send_new_order (side, quantity,
_limit.long_position_limit(), _limit.short_position_limit(),
_long_pos, _short_pos);
//TODO: text in result
_long_pos, _short_pos) &&
_product_limit_state.can_send_new_order(side, quantity).ok;
return result;
}
Limiter::LimiterQueryResult can_update_order(api::Side side, Quantity from, Quantity to){
Limiter::LimiterQueryResult can_update_order(api::Side side, Quantity from, Quantity to) const{
Limiter::LimiterQueryResult result; result.ok = true;
result.ok = ProductLimitTree::can_update_order (side, from, to, _limit.long_position_limit(), _limit.short_position_limit(),
_long_pos, _short_pos);
_long_pos, _short_pos) &&
_product_limit_state.can_update_order(side, from, to).ok;
return result;
}
};
@@ -74,7 +83,7 @@ public:
const bts::api::admin::AccountSecurityPositionLimitUnit& zero_limit)
{
for(int i=0; i<admin_data.accounts_size(); i++){
auto account = admin_data.accounts(i);
const auto& account = admin_data.accounts(i);
ProductLimitTree::ProductAccountLimitState& product_limit_unit = *(product_tree.find_account(account.id()));
const bts::api::admin::AccountSecurityPositionLimitUnit* limit = bts::admin::AdminServiceUtils::find_account_security_position_limit(account, security);
_tree.emplace_back(account.id(), account.has_parent_account_id() ? account.parent_account_id().id() : 0, limit != nullptr ? *limit : zero_limit, product_limit_unit);
@@ -116,14 +125,14 @@ public:
}
void copy_positions_from(SecurityLimitTree& source){
for (auto it=_tree.begin(); it!=_tree.end(); it++){
SecurityAccountLimitState* source_account_limit_ptr = source.find_account(it->account_id);
SecurityAccountLimitState* source_account_limit_ptr = source.find_account(it->account_id());
if(source_account_limit_ptr != nullptr)
it->copy_positions_from(*source_account_limit_ptr);
}
}
SecurityAccountLimitState* find_account (int account_id){
for(auto it=_tree.begin(); it!=_tree.end(); it++)
if(it->account_id==account_id)
if(it->account_id()==account_id)
return &*it;
return nullptr;
}
@@ -0,0 +1,252 @@
#include "catch/catch.hpp"
#include <memory>
#include "server/sparkd/orderman/limiter/LimitStore.h"
#include "server/sparkd/orderman/limiter/Limiter.h"
#include "lib/api/services/AdminService.server.pb.h"
#include "lib/api/service_helpers/AdminServiceUtils.h"
#include "lib/domain_model/Security.h"
#include "lib/utils/bts_chrono.h"
#include "lib/utils/helper_macros.h"
#include "lib/config/config.h"
namespace bts{
namespace orderman{
void add_account_prod_pos_limit(bts::api::admin::AdminData& admin_data,
const std::string& account_name,
api::Venue prod_exchange,
api::SecurityType prod_type,
const std::string& prod_symbol,
uint32_t long_pos_limit,
uint32_t short_pos_limit){
auto account_ptr = bts::admin::AdminServiceUtils::find_account(admin_data, account_name);
REQUIRE(account_ptr!=nullptr);
bts::api::admin::ProductScope prod_scope;
prod_scope.set_exchange(prod_exchange);
prod_scope.set_security_type(prod_type);
prod_scope.set_security_symbol(prod_symbol);
auto new_prod_pos_limit_ptr = account_ptr->mutable_product_position_limits()->Add();
new_prod_pos_limit_ptr->mutable_product()->CopyFrom(prod_scope);
new_prod_pos_limit_ptr->set_long_position_limit(long_pos_limit);
new_prod_pos_limit_ptr->set_short_position_limit(short_pos_limit);
}
void add_account_security_pos_limit(bts::api::admin::AdminData& admin_data,
const std::string& account_name,
api::Venue sec_exchange,
api::SecurityType sec_type,
const std::string& sec_symbol,
uint32_t sec_id, //0 for unset
uint32_t long_pos_limit,
uint32_t short_pos_limit){
auto account_ptr = bts::admin::AdminServiceUtils::find_account(admin_data, account_name);
REQUIRE(account_ptr!=nullptr);
bts::api::admin::SecurityScope sec_scope;
sec_scope.set_exchange(sec_exchange);
sec_scope.set_security_type(sec_type);
sec_scope.set_security_symbol(sec_symbol);
if(sec_id != 0)
sec_scope.mutable_security_id()->set_id(sec_id);
auto new_sec_pos_limit_ptr = account_ptr->mutable_security_position_limits()->Add();
new_sec_pos_limit_ptr->mutable_security()->CopyFrom(sec_scope);
new_sec_pos_limit_ptr->set_long_position_limit(long_pos_limit);
new_sec_pos_limit_ptr->set_short_position_limit(short_pos_limit);
}
void fill_future_security (api::Security& sec,
uint32_t key, const std::string& symbol, api::Venue exchange,
uint32_t expiration_year, uint32_t expiration_month, uint32_t expiration_day,
double tick_size)
{
sec.set_id (key);
sec.set_symbol (symbol);
sec.set_exchange (exchange);
api::FutureContract fc;
fc.set_expiration_year(expiration_year);
fc.set_expiration_month(expiration_month);
fc.set_expiration_day(expiration_day);
sec.mutable_future()->MergeFrom (fc);
api::ContractSpecification c_spec;
c_spec.set_low_tick (tick_size);
c_spec.set_high_tick (tick_size);
sec.mutable_contract_spec()->MergeFrom (c_spec);
}
void verify_security_limit_data(SecurityLimitTree::SecurityAccountLimitState const* acc_sec_state,
uint32_t expected_long_limit, uint32_t expected_short_limit,
uint32_t expected_long_pos, uint32_t expected_short_pos){
REQUIRE(acc_sec_state != nullptr);
REQUIRE(acc_sec_state->limit().long_position_limit() == expected_long_limit);
REQUIRE(acc_sec_state->limit().short_position_limit() == expected_short_limit);
REQUIRE(acc_sec_state->long_pos() == expected_long_pos);
REQUIRE(acc_sec_state->short_pos() == expected_short_pos);
}
void verify_product_limit_data(ProductLimitTree::ProductAccountLimitState const* acc_prod_state,
uint32_t expected_long_limit, uint32_t expected_short_limit,
uint32_t expected_long_pos, uint32_t expected_short_pos){
REQUIRE(acc_prod_state != nullptr);
REQUIRE(acc_prod_state->limit().long_position_limit() == expected_long_limit);
REQUIRE(acc_prod_state->limit().short_position_limit() == expected_short_limit);
REQUIRE(acc_prod_state->long_pos() == expected_long_pos);
REQUIRE(acc_prod_state->short_pos() == expected_short_pos);
}
TEST_CASE ("Creation", "[limiter]"){
api::Security sec_1, sec_2;
fill_future_security(sec_1, 1000, std::string("ES"), api::Venue::VENUE_GLBX, 2020, 1, 1, 0.25);
fill_future_security(sec_2, 2000, std::string("ES"), api::Venue::VENUE_GLBX, 2021, 1, 1, 0.25);
std::vector<api::Security const*> sec_vec;
sec_vec.push_back(&sec_1);
sec_vec.push_back(&sec_2);
bts::api::admin::AdminData admin_data;
bts::admin::AdminServiceUtils::bootstrap_data(admin_data);
std::string account_name = "account_1";
bts::api::admin::BTSAccount* account_ptr = bts::admin::AdminServiceUtils::find_account(admin_data, account_name);
add_account_prod_pos_limit (admin_data, account_ptr->name(), bts::api::Venue::VENUE_GLBX,
bts::api::SecurityType::SECURITYTYPE_FUTURE, std::string("ES"), 100, 50);
add_account_security_pos_limit(admin_data, account_ptr->name(), bts::api::Venue::VENUE_GLBX,
bts::api::SecurityType::SECURITYTYPE_FUTURE, std::string("ES"), sec_1.id(), 50, 25);
Limiter limiter;
limiter.update(admin_data);
limiter.add_securities(sec_vec);
LimitStore& limit_store = limiter.limit_store();
// test basics
SECTION("basic access_data"){
SecurityLimitTree::SecurityAccountLimitState const* acc_sec_1_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_1.id());
verify_security_limit_data (acc_sec_1_state, 50, 25, 0, 0);
SecurityLimitTree::SecurityAccountLimitState const* acc_sec_2_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_2.id());
verify_security_limit_data (acc_sec_2_state, 0, 0, 0, 0);
// buys: add and removes on sec_1
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(8));
verify_security_limit_data (acc_sec_1_state, 50, 25, 8, 0);
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(7));
verify_security_limit_data (acc_sec_1_state, 50, 25, 15, 0);
limiter.remove(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(5));
verify_security_limit_data (acc_sec_1_state, 50, 25, 10, 0);
// sells: adds amd removes on sec_1
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(2));
verify_security_limit_data (acc_sec_1_state, 50, 25, 10, 2);
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(8));
verify_security_limit_data (acc_sec_1_state, 50, 25, 10, 10);
limiter.remove(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(5));
verify_security_limit_data (acc_sec_1_state, 50, 25, 10, 5);
// buys: add and removes on sec_2 (should not be allowed though)
limiter.add(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(113));
verify_security_limit_data (acc_sec_2_state, 0, 0, 113, 0);
limiter.remove(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(108));
verify_security_limit_data (acc_sec_2_state, 0, 0, 5, 0);
// sell: add and removes on sec_2 (should not be allowed though)
limiter.add(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(13));
verify_security_limit_data (acc_sec_2_state, 0, 0, 5, 13);
limiter.remove(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(3));
verify_security_limit_data (acc_sec_2_state, 0, 0, 5, 10);
// check position data
api::Product product;
product.set_exchange(sec_1.exchange()); product.set_type(bts::admin::AdminServiceUtils::security_type(sec_1)); product.set_symbol(sec_1.symbol());
ProductLimitTree::ProductAccountLimitState const* acc_prod_state = limit_store.find_product_account_state(AccountID(account_ptr->id()), product);
verify_product_limit_data (acc_prod_state, 100, 50, 15, 15);
}
SECTION("new securities"){
// trade on new securties
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_1_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_1.id());
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_2_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_2.id());
api::Product product;
product.set_exchange(sec_1.exchange()); product.set_type(bts::admin::AdminServiceUtils::security_type(sec_1)); product.set_symbol(sec_1.symbol());
ProductLimitTree::ProductAccountLimitState const* acc_prod_state = limit_store.find_product_account_state(AccountID(account_ptr->id()), product);
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(3));
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(14));
limiter.add(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(2));
limiter.add(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(71));
verify_security_limit_data (acc_sec_1_state, 50, 25, 3, 14);
verify_security_limit_data (acc_sec_2_state, 0, 0, 2, 71);
verify_product_limit_data (acc_prod_state, 100, 50, 5, 85);
// make a trade on a new security (same as adding a security)
api::Security sec_3;
fill_future_security(sec_3, 3000, std::string("ES"), api::Venue::VENUE_GLBX, 2022, 1, 1, 0.25);
limiter.add(sec_3, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(99));
// this will internally create a new LimitStore and reshuffle thing
LimitStore& reshuff_limit_store = limiter.limit_store();
acc_sec_1_state = reshuff_limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_1.id());
acc_sec_2_state = reshuff_limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_2.id());
acc_prod_state = reshuff_limit_store.find_product_account_state(AccountID(account_ptr->id()), product);
verify_security_limit_data (acc_sec_1_state, 50, 25, 3, 14);
verify_security_limit_data (acc_sec_2_state, 0, 0, 2, 71);
verify_product_limit_data (acc_prod_state, 100, 50, 104, 85);
}
SECTION("new admin data"){
// trade on new securties
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_1_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_1.id());
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_2_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_2.id());
api::Product product;
product.set_exchange(sec_1.exchange()); product.set_type(bts::admin::AdminServiceUtils::security_type(sec_1)); product.set_symbol(sec_1.symbol());
ProductLimitTree::ProductAccountLimitState const* acc_prod_state = limit_store.find_product_account_state(AccountID(account_ptr->id()), product);
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(3));
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(14));
limiter.add(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(2));
limiter.add(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_SELL, Quantity(71));
verify_security_limit_data (acc_sec_1_state, 50, 25, 3, 14);
verify_security_limit_data (acc_sec_2_state, 0, 0, 2, 71);
verify_product_limit_data (acc_prod_state, 100, 50, 5, 85);
// reset admin data
account_ptr->mutable_security_position_limits(0)->set_long_position_limit(422);
account_ptr->mutable_product_position_limits(0)->set_short_position_limit(507);
verify_security_limit_data (acc_sec_1_state, 50, 25, 3, 14);
verify_security_limit_data (acc_sec_2_state, 0, 0, 2, 71);
verify_product_limit_data (acc_prod_state, 100, 50, 5, 85);
limiter.update(admin_data);
LimitStore& reshuff_limit_store = limiter.limit_store();
acc_sec_1_state = reshuff_limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_1.id());
acc_sec_2_state = reshuff_limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_2.id());
acc_prod_state = reshuff_limit_store.find_product_account_state(AccountID(account_ptr->id()), product);
verify_security_limit_data (acc_sec_1_state, 422, 25, 3, 14);
verify_security_limit_data (acc_sec_2_state, 0, 0, 2, 71);
verify_product_limit_data (acc_prod_state, 100, 507, 5, 85);
}
SECTION("post limit"){
// trade on new securties
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_1_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_1.id());
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_2_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_2.id());
api::Product product;
product.set_exchange(sec_1.exchange()); product.set_type(bts::admin::AdminServiceUtils::security_type(sec_1)); product.set_symbol(sec_1.symbol());
ProductLimitTree::ProductAccountLimitState const* acc_prod_state = limit_store.find_product_account_state(AccountID(account_ptr->id()), product);
add_account_security_pos_limit(admin_data, account_ptr->name(), bts::api::Venue::VENUE_GLBX,
bts::api::SecurityType::SECURITYTYPE_FUTURE, std::string("ES"), sec_2.id(), 75, 50);
limiter.update(admin_data);
REQUIRE(limiter.can_send_new_order(AccountID(account_ptr->id()), sec_1, api::Side::SIDE_BUY, Quantity(49)).ok);
REQUIRE(!limiter.can_send_new_order(AccountID(account_ptr->id()), sec_1, api::Side::SIDE_BUY, Quantity(51)).ok);
REQUIRE(limiter.can_send_new_order(AccountID(account_ptr->id()), sec_1, api::Side::SIDE_SELL, Quantity(24)).ok);
REQUIRE(!limiter.can_send_new_order(AccountID(account_ptr->id()), sec_1, api::Side::SIDE_SELL, Quantity(26)).ok);
REQUIRE(limiter.can_send_new_order(AccountID(account_ptr->id()), sec_2, api::Side::SIDE_BUY, Quantity(74)).ok);
REQUIRE(!limiter.can_send_new_order(AccountID(account_ptr->id()), sec_2, api::Side::SIDE_BUY, Quantity(76)).ok);
REQUIRE(limiter.can_send_new_order(AccountID(account_ptr->id()), sec_2, api::Side::SIDE_SELL, Quantity(49)).ok);
REQUIRE(!limiter.can_send_new_order(AccountID(account_ptr->id()), sec_2, api::Side::SIDE_SELL, Quantity(51)).ok);
limiter.add(sec_1, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(30));
REQUIRE(limiter.can_send_new_order(AccountID(account_ptr->id()), sec_1, api::Side::SIDE_BUY, Quantity(19)).ok);
REQUIRE(!limiter.can_send_new_order(AccountID(account_ptr->id()), sec_1, api::Side::SIDE_BUY, Quantity(21)).ok);
limiter.add(sec_2, AccountID(account_ptr->id()), api::Side::SIDE_BUY, Quantity(60));
// product limit getting hit
REQUIRE(limiter.can_send_new_order(AccountID(account_ptr->id()), sec_2, api::Side::SIDE_BUY, Quantity(9)).ok);
REQUIRE(!limiter.can_send_new_order(AccountID(account_ptr->id()), sec_2, api::Side::SIDE_BUY, Quantity(11)).ok);
}
SECTION("can trade user, account"){
// trade on new securties
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_1_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_1.id());
const SecurityLimitTree::SecurityAccountLimitState* acc_sec_2_state = limit_store.find_security_account_state(AccountID(account_ptr->id()), sec_2.id());
REQUIRE(limiter.can_trade (UserID(1), AccountID(1)).ok);
REQUIRE(!limiter.can_trade (UserID(1), AccountID(10)).ok);
}
}
}}