SPARK-1022
This commit is contained in:
1 parent
b773e801f7
commit
f4a2b788ff
9 files changed
+484
-91
No files matched your search
Vendored
+32
@@ -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",
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
};
|
||||
}}
|
||||
@@ -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)
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
}}
|
||||
Reference in new issue
Block a user