Files
spark/src/server/sparkd/position/MarginServiceServer.cpp
T

229 lines
8.1 KiB
C++

#include "MarginServiceServer.h"
#include "MarginServiceCore.h"
#include "PositionAggregator.h"
#include "Position.h"
#include "lib/api/service_helpers/AdminServiceUtils.h"
#include "lib/orderman/orderman_utils/orderman_utils.h"
#include "lib/persistence/SqliteStore.h"
#include "lib/config/config.h"
#include "lib/config/protos/toggles.pb.h"
#include "lib/domain_model/Security.h"
#include "lib/logging/logging.h"
#include "lib/utils/bts_assert.h"
#include "lib/utils/TimeStamp.h"
#include "lib/utils/Dispatcher.h"
#include <set>
#include <utility>
using namespace bts::api::orderman;
using namespace bts::api::position;
using namespace bts::admin;
using namespace std;
using bts::api::position::MarginResult;
namespace bts {
namespace position {
MarginServiceServer::MarginServiceServer(bts::api::ServiceContext& context, md::MDClient& mdclient)
: bts::api::position::MarginServiceBase (context),
_admin_service(context.locate<bts::api::admin::AdminService>()),
_publisher(make_margin_data_stateful_publisher()),
_report_publisher(make_excess_liquidity_report_stateful_publisher()),
_dispatcher(utils::Dispatcher::get_named("MarginServiceServer")),
_timer(_dispatcher, 60000, [=]() { publish_all();} ),
_position(new PositionAggregator(context.locate<bts::api::position::PositionService>(), mdclient)),
_margin(new MarginServiceCore(_dispatcher)),
//state below
_lock(),
_last_update(),
_admin_data(),
_last_report()
{
LOG(Gen, Info, "MarginServiceServer: service started");
_admin_data = *_admin_service.get_admin_data(api::VoidMessage()).value();
_admin_service.subscribe_admin_data() |
rxcpp::operators::subscribe<api::admin::Admin_dataUpdate>(
[this](auto const &update)
{
std::scoped_lock<std::recursive_mutex> l(_lock);
bts_assert(update.all().size() == 1);
_admin_data = *update.all()[0];
});
publish_all();
_timer.start();
}
void MarginServiceServer::publish_all()
{
if(config::get<bts::config::toggles::SpanMargin>().enabled())
{
std::scoped_lock<std::recursive_mutex> l(_lock);
auto accts = AdminServiceUtils::accounts(_admin_data, false);
for(const auto& i : accts)
{
datetime::LLDateTime since = 0;
std::string acct = i->name();
auto it = _last_update.find(acct);
if(it != _last_update.end())
since = it->second;
std::vector<Position> pos;
if(_position->query_positions(acct, pos, &since) && pos.size())
{
LOG(Gen, Info, "MarginServiceServer: computing margin for {} ", acct);
auto aname = orderman::to<orderman::AccountName>(acct);
_margin->compute_margin(aname, pos, [this, since, acct](const MarginResult& m)
{
std::scoped_lock<std::recursive_mutex> l(_lock);
publish_margin(m);
_last_update[acct] = since;
});
}
}
}
}
MarginServiceServer::~MarginServiceServer() {}
void MarginServiceServer::get_margin(const api::position::MarginRequest& request,
const api::Response<api::position::MarginResult>& reply)
{
if(!config::get<bts::config::toggles::SpanMargin>().enabled())
{
MarginResult res;
res.set_account(request.account());
reply(res);
}
else
{
orderman::AccountName acct;
orderman::str_to(request.account(), &acct);
std::vector<Position> pos;
_position->query_positions(request.account(), pos);
_margin->compute_margin(acct, pos, [=](const MarginResult& m)
{
reply(m);
});
}
}
void MarginServiceServer::get_excess_liquidity_report(const api::position::MarginRequest& request,
const api::Response<api::position::ExcessLiquidityReport>& reply)
{
std::scoped_lock<std::recursive_mutex> l(_lock);
ExcessLiquidityReport rep;
rep.set_account(request.account());
auto it = _last_report.find(request.account());
if(it != _last_report.end())
rep.CopyFrom(it->second);
reply(rep);
}
void MarginServiceServer::publish_margin(const api::position::MarginResult& result)
{
std::scoped_lock<std::recursive_mutex> l(_lock);
_publisher.add_or_update(result);
_publisher.flush();
publish_excess_liquidity_report(result);
}
void MarginServiceServer::publish_excess_liquidity_report(const api::position::MarginResult& result)
{
std::scoped_lock<std::recursive_mutex> l(_lock);
ExcessLiquidityReport report;
report.set_account(result.account());
report.mutable_margin_result()->CopyFrom(result);
auto acct = AdminServiceUtils::find_account(_admin_data, result.account(), false);
double netliq = 0.0;
if(acct && acct->has_margin_limit())
{
report.set_leverage_factor( acct->margin_limit().leverage_factor_percentage() );
report.set_cash_balance(acct->margin_limit().cash_balance());
netliq = report.leverage_factor() * report.cash_balance();
}
netliq -= result.maint_margin();
report.set_excess_liquidity(netliq);
_last_report[result.account()] = report;
_report_publisher.add_or_update(report);
_report_publisher.flush();
}
void MarginServiceServer::update_report(const std::string& account)
{
MarginResult res;
auto acct = orderman::to<orderman::AccountName>(account);
if(_margin->get_last_valid_result(acct, res))
publish_excess_liquidity_report(res);
}
void MarginServiceServer::set_cash_factor(const ::bts::api::position::CashFactorUpdate& request,
const api::Response<::bts::api::ResultMessage>& reply)
{
std::scoped_lock<std::recursive_mutex> l(_lock);
auto acct = AdminServiceUtils::find_account(_admin_data, request.account(), false);
if(!acct)
{
auto msg = "Account " + request.account() +"not found";
api::ResultMessage resp;
resp.set_success(false);
resp.set_error_message(msg);
reply(resp);
}
else
{
acct->mutable_margin_limit()->set_leverage_factor_percentage(request.leverage_factor());
AccountUpdateAPIArgument update;
update.mutable_complete_data()->CopyFrom(*acct);
_admin_service.update_account(update,
[this, request, reply](const api::Result<bts::api::admin::AdminServiceOperationResult>& admin_result)
{
api::ResultMessage resp;
resp.set_success(admin_result.success());
resp.set_error_message(admin_result.error_message());
reply(resp);
update_report(request.account());
});
}
}
void MarginServiceServer::set_cash_balance(const ::bts::api::position::CashBalanceUpdate& request,
const api::Response<::bts::api::ResultMessage>& reply)
{
std::scoped_lock<std::recursive_mutex> l(_lock);
auto acct = AdminServiceUtils::find_account(_admin_data, request.account(), false);
if(!acct)
{
auto msg = "Account " + request.account() +"not found";
api::ResultMessage resp;
resp.set_success(false);
resp.set_error_message(msg);
reply(resp);
}
else
{
acct->mutable_margin_limit()->set_cash_balance(request.cash_balance());
AccountUpdateAPIArgument update;
update.mutable_complete_data()->CopyFrom(*acct);
_admin_service.update_account(update,
[this, request, reply](const api::Result<bts::api::admin::AdminServiceOperationResult>& admin_result)
{
api::ResultMessage resp;
resp.set_success(admin_result.success());
resp.set_error_message(admin_result.error_message());
reply(resp);
update_report(request.account());
});
}
}
}}