diff --git a/.vscode/launch.json b/.vscode/launch.json index feefeda96..2f009c60a 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -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", diff --git a/src/lib/api/service_helpers/AdminServiceUtils.h b/src/lib/api/service_helpers/AdminServiceUtils.h index cd40922df..2307b2bcc 100644 --- a/src/lib/api/service_helpers/AdminServiceUtils.h +++ b/src/lib/api/service_helpers/AdminServiceUtils.h @@ -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 accounts_map(bts::api::admin::AdminData& admin_data){ + static std::map accounts_map(const bts::api::admin::AdminData& admin_data){ std::map rv; for(int i=0; i(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(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> user_account_map(bts::api::admin::AdminData& admin_data){ + static std::map> user_account_map(const bts::api::admin::AdminData& admin_data){ std::map> rv; for(int i=0; i 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(security.id())) //TODO + if(limit.security().has_security_id()){ + if (static_cast(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; } }; }} \ No newline at end of file diff --git a/src/server/sparkd/CMakeLists.txt b/src/server/sparkd/CMakeLists.txt index 821dc4aa9..49c58c3f8 100644 --- a/src/server/sparkd/CMakeLists.txt +++ b/src/server/sparkd/CMakeLists.txt @@ -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) \ No newline at end of file +file(COPY jetfix/tests/sample_fix.dat DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test_data) diff --git a/src/server/sparkd/orderman/limiter/LimitStore.h b/src/server/sparkd/orderman/limiter/LimitStore.h index d416727a3..8bbbecb0e 100644 --- a/src/server/sparkd/orderman/limiter/LimitStore.h +++ b/src/server/sparkd/orderman/limiter/LimitStore.h @@ -18,6 +18,7 @@ namespace orderman { class LimitStore{ private: + bts::api::admin::AdminData _admin_data; const std::map _account_map; // just an easy way to find accounts const std::map> _user_account_map; std::map _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& 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(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(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(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 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 diff --git a/src/server/sparkd/orderman/limiter/Limiter.cpp b/src/server/sparkd/orderman/limiter/Limiter.cpp index bc6ed0f11..746353439 100644 --- a/src/server/sparkd/orderman/limiter/Limiter.cpp +++ b/src/server/sparkd/orderman/limiter/Limiter.cpp @@ -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 securities; + std::unique_ptr limit_store; + PImpl() + : + securities(), + limit_store(std::make_unique(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 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 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; } +}} diff --git a/src/server/sparkd/orderman/limiter/Limiter.h b/src/server/sparkd/orderman/limiter/Limiter.h index 2fe543a8e..991977cb4 100644 --- a/src/server/sparkd/orderman/limiter/Limiter.h +++ b/src/server/sparkd/orderman/limiter/Limiter.h @@ -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 me; diff --git a/src/server/sparkd/orderman/limiter/ProductLimitTree.h b/src/server/sparkd/orderman/limiter/ProductLimitTree.h index 7ba436147..a0bebf1e4 100644 --- a/src/server/sparkd/orderman/limiter/ProductLimitTree.h +++ b/src/server/sparkd/orderman/limiter/ProductLimitTree.h @@ -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 _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; iaccount_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 diff --git a/src/server/sparkd/orderman/limiter/SecurityLimitTree.h b/src/server/sparkd/orderman/limiter/SecurityLimitTree.h index cd7d3f290..6750adf57 100644 --- a/src/server/sparkd/orderman/limiter/SecurityLimitTree.h +++ b/src/server/sparkd/orderman/limiter/SecurityLimitTree.h @@ -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; iaccount_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; } diff --git a/src/server/sparkd/orderman/limiter/tests/limit_tests.cpp b/src/server/sparkd/orderman/limiter/tests/limit_tests.cpp new file mode 100644 index 000000000..fce7c9085 --- /dev/null +++ b/src/server/sparkd/orderman/limiter/tests/limit_tests.cpp @@ -0,0 +1,252 @@ +#include "catch/catch.hpp" +#include +#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 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); + } +} +}}