124 lines
4.0 KiB
C++
124 lines
4.0 KiB
C++
#include "RiskLimitManager.h"
|
|
|
|
#include "server/sparkd/risk_limits/RiskLimiter.h"
|
|
|
|
#include "server/sparkd/order_man/OrderCreate.h"
|
|
#include "server/sparkd/order_man/OrderUpdate.h"
|
|
#include "server/sparkd/order_man/OrderState.h"
|
|
|
|
#include "lib/config/config.h"
|
|
#include "lib/config/protos/Account.pb.h"
|
|
#include "lib/config/protos/User.pb.h"
|
|
|
|
#include "lib/utils/bts_assert.h"
|
|
#include "lib/logging/logging.h"
|
|
|
|
#include <boost/container/flat_map.hpp>
|
|
#include <tuple>
|
|
|
|
using namespace bts::orderman;
|
|
|
|
namespace bts {
|
|
namespace risklimits {
|
|
|
|
using OperatorMap = boost::container::flat_map<std::string, config::Operator>;
|
|
using KeyType = std::tuple<AccountName, orderman::OperatorID, orderman::SymbolName>;
|
|
using LimiterMap = boost::container::flat_map<KeyType, std::shared_ptr<RiskLimiter>>;
|
|
|
|
struct RiskLimitManager::PImpl
|
|
{
|
|
OperatorMap operator_map;
|
|
LimiterMap limiter_map;
|
|
|
|
PImpl() :
|
|
operator_map(), limiter_map()
|
|
{
|
|
auto users = config::get<config::UserCfg>();
|
|
for(int i = 0; i < users.user_size(); i++)
|
|
{
|
|
auto user = users.user(i);
|
|
for(int j = 0; i < user.operators_size(); j++)
|
|
operator_map[user.operators(j).operator_id().id()] = user.operators(j);
|
|
}
|
|
|
|
auto accts = config::get<config::AccountCfg>();
|
|
for(int i = 0; i < accts.accounts_size(); i++)
|
|
{
|
|
const auto& acct = accts.accounts(i).account();
|
|
const auto& limit = accts.accounts(i).limits();
|
|
for(auto j = limit.begin(); j != limit.end(); j++)
|
|
{
|
|
for(int k = 0; k < acct.allowed_operators_size(); k++)
|
|
{
|
|
auto allowed = operator_map.find(acct.allowed_operators(k).id());
|
|
if(allowed != operator_map.end())
|
|
{
|
|
orderman::OperatorID opid = to<OperatorID>(allowed->second.operator_id().id());
|
|
KeyType key(to_accountname(acct), opid, to_symbolname(j->first));
|
|
RiskLimiter* lim = new RiskLimiter(std::get<0>(key), std::get<1>(key), std::get<2>(key));
|
|
limiter_map[key] = std::shared_ptr<RiskLimiter>(lim);
|
|
lim->on_account_update(acct);
|
|
lim->on_operator_update(allowed->second);
|
|
lim->on_risk_limit_update(j->second);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
orderman::SymbolName to_symbolname(SecurityKey)
|
|
{
|
|
return to_symbolname("ES");
|
|
}
|
|
orderman::SymbolName to_symbolname(const std::string& key)
|
|
{
|
|
return orderman::SymbolName(key);
|
|
}
|
|
orderman::AccountName to_accountname(const config::Account& key)
|
|
{
|
|
return to<orderman::AccountName> (key.account_id());
|
|
}
|
|
|
|
RiskLimiter& find_limiter(AccountName acctname, orderman::OperatorID opid, orderman::SymbolName symbolname)
|
|
{
|
|
KeyType key(acctname, opid, symbolname);
|
|
auto lim = limiter_map.find(key);
|
|
if(lim != limiter_map.end())
|
|
return *lim->second;
|
|
else
|
|
{
|
|
RiskLimiter* lim = new RiskLimiter(std::get<0>(key), std::get<1>(key), std::get<2>(key));
|
|
auto ptr = std::shared_ptr<RiskLimiter>(lim);
|
|
limiter_map[key] = ptr;
|
|
return *ptr;
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
RiskLimitManager::RiskLimitManager() : me(new PImpl())
|
|
{
|
|
}
|
|
|
|
RiskLimitManager::~RiskLimitManager()
|
|
{
|
|
}
|
|
|
|
const RiskLimiter& RiskLimitManager::find_limiter(AccountName acctname, orderman::OperatorID opid, orderman::SymbolName symbolname)
|
|
{
|
|
return me->find_limiter(acctname, opid, symbolname);
|
|
}
|
|
|
|
void RiskLimitManager::on_orderman_ready() { }
|
|
void RiskLimitManager::on_orderman_disconnected() { }
|
|
void RiskLimitManager::on_order_create(const orderman::OrderState &) { }
|
|
|
|
void RiskLimitManager::on_order_change(const orderman::OrderState& state)
|
|
{
|
|
RiskLimiter& lim = me->find_limiter(state.account_name, state.operator_id, me->to_symbolname(state.security_key));
|
|
lim.on_order_change(state);
|
|
}
|
|
|
|
}
|
|
}
|