Files
spark/src/server/sparkd/position/PositionServiceServer.cpp
T
2019-06-20 15:28:27 -04:00

341 lines
12 KiB
C++

#include "PositionServiceServer.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/api/services/OrderService.client.pb.h"
#include "lib/api/public/ServiceContext.h"
#include "lib/logging/logging.h"
#include "lib/utils/PBUtils.h"
#include "lib/persistence/SqliteStore.h"
#include "lib/utils/Puid.h"
#include "PositionServicePNLHelper.h"
#include <boost/algorithm/string.hpp>
#include <boost/tokenizer.hpp>
#include <fmt/format.h>
#include <map>
#include <set>
#include <utility>
namespace bts {
namespace position{
using namespace bts::api::position;
using namespace bts::api::orderman;
using namespace bts::md;
static auto const manual_fills_ns = "manual_fills";
struct PositionServiceServer::PImpl {
bts::api::ServiceContext& context;
PositionServiceBase::Position_dataStatefulPublisher publisher;
PositionServiceBase::Pnl_dataStatefulPublisher pnl_publisher;
PositionServiceBase::Pnl_account_dataStatefulPublisher pnl_account_publisher;
bts::api::orderman::OrderService order_service;
std::map<std::string, std::map<uint32_t, PositionUnit>> state;
std::map<uint32_t, ManualFill> manual_fills;
int id;
PositionServicePNLHelper pnl_helper;
int64_t poll_period_ms;
// manual fills management
std::unique_ptr<persistence::IStore> manual_fills_store ;
PositionServiceBase::Manual_fillsStatefulPublisher manual_fills_publisher;
PImpl(bts::api::ServiceContext& context,
const PositionServiceBase::Position_dataStatefulPublisher& publisher,
const PositionServiceBase::Pnl_dataStatefulPublisher& pnl_publisher,
const PositionServiceBase::Pnl_account_dataStatefulPublisher& pnl_account_publisher,
const PositionServiceBase::Manual_fillsStatefulPublisher &manual_fills_publisher,
bts::md::MDClient& md_client)
:
context(context),
publisher(publisher),
pnl_publisher(pnl_publisher),
pnl_account_publisher(pnl_account_publisher),
order_service(context.locate<bts::api::orderman::OrderService>()),
state(),
id(0),
pnl_helper(md_client),
poll_period_ms(1000),
manual_fills_store(std::make_unique<persistence::SqliteStore> ("manual_fills")),
manual_fills_publisher(manual_fills_publisher)
{
}
};
PositionServiceServer::PositionServiceServer(bts::api::ServiceContext& context,
bts::md::MDClient& md_client)
:
PositionServiceBase (context),
me(new PImpl(context,
make_position_data_stateful_publisher(),
make_pnl_data_stateful_publisher(),
make_pnl_account_data_stateful_publisher(),
make_manual_fills_stateful_publisher(),
md_client))
{
me->order_service.subscribe_fills() |
rxcpp::operators::subscribe<api::orderman::FillsUpdate>(
[this](auto const& update) {
for (const auto& f : update.removed())
me->publisher.add_or_update(_on_fill(*f,false));
for (const auto& f : update.added())
me->publisher.add_or_update(_on_fill(*f,true));
for (const auto& f : update.changed()) {
me->publisher.add_or_update(_on_fill(*f.previous(),false));
me->publisher.add_or_update(_on_fill(*f.current(),true));
}
me->publisher.flush();
_compute_pnl_and_publish();
});
me->context.post([this](){_periodic_poll();},me->poll_period_ms);
auto all = me->manual_fills_store->retrieve_all()[manual_fills_ns];
LOG(persist, Info, "Finished loading all {} manual fills", all.size());
ManualFill rec;
for (auto const &kvp : all)
if (utils::pb::from_string<ManualFill>(kvp.second, &rec)) {
me->manual_fills.insert({rec.record_id(), rec});
me->manual_fills_publisher.add_or_update(rec);
me->publisher.add_or_update(_on_fill(to_fill(rec),true));
}
else {
LOG(OrderMan, Error,
"Could not recover manual fill {} from storage. "
"This should be investigated",
kvp.first);
}
me->manual_fills_publisher.flush();
me->publisher.flush();
}
bts::api::orderman::Fill PositionServiceServer::to_fill(bts::api::position::ManualFill const&src)
{
using namespace api::orderman;
bts::api::orderman::Fill result;
result.set_account(src.account_name());
result.set_security_key(src.security_key());
result.set_last_price(src.price());
result.set_side(src.side());
result.set_last_shares(src.quantity());
result.set_fill_kind(Fill::FILL_KIND_STANDARD);
result.set_fill_key(std::string("manual:")+std::to_string(src.record_id()));
return result;
}
const PositionUnit& PositionServiceServer::_on_fill (const Fill& f,
bool is_add){
std::string fill_account=_fill_account(f);
PositionUnit& pu=_get_or_add(fill_account,f.internal_account_id(),
f.security_key());
double avg_price, tot_qty;
if(f.fill_kind()==bts::api::orderman::Fill::FILL_KIND_SOD){
if(f.side()==api::Side::SIDE_BUY){
_avg_price_qty(pu.sod_long_avg_price(),pu.sod_long_pos(),
f.last_price(),f.last_shares(),
is_add,f.fill_key(),
avg_price, tot_qty);
pu.set_sod_long_avg_price(avg_price);
pu.set_sod_long_pos(tot_qty);
}
else{
_avg_price_qty(pu.sod_short_avg_price(),pu.sod_short_pos(),
f.last_price(),f.last_shares(),
is_add,f.fill_key(),
avg_price, tot_qty);
pu.set_sod_short_avg_price(avg_price);
pu.set_sod_short_pos(tot_qty);
}
}
else{
if(f.side()==api::Side::SIDE_BUY){
_avg_price_qty(pu.day_long_avg_price(),pu.day_long_pos(),
f.last_price(),f.last_shares(),
is_add,f.fill_key(),
avg_price, tot_qty);
pu.set_day_long_avg_price(avg_price);
pu.set_day_long_pos(tot_qty);
}
else{
_avg_price_qty(pu.day_short_avg_price(),pu.day_short_pos(),
f.last_price(),f.last_shares(),
is_add,f.fill_key(),
avg_price, tot_qty);
pu.set_day_short_avg_price(avg_price);
pu.set_day_short_pos(tot_qty);
}
}
return pu;
}
PositionUnit& PositionServiceServer::_get_or_add (const std::string& acct,
uint32_t account_id,
uint32_t seckey){
auto &pu = me->state[acct][seckey];
if (pu.record_id() == 0) {
// new PU
pu.set_record_id(++me->id);
pu.set_account(acct);
pu.set_account_id(account_id);
pu.set_security_id(seckey);
}
return pu;
}
void PositionServiceServer::_avg_price_qty(double base_p,
double base_q,
double fill_p,
double fill_q,
bool is_add,
const std::string& fill_id,
double& avg_price,
double& tot_qty){
if(fill_q<0){
LOG(OrderMan,Error,"PositionServiceServer::_avg_price_qty "
"fill_id:{} fill_q:{} is_add:{}",
fill_id, fill_q, is_add);
fill_q=0;
}
if(is_add){
tot_qty=base_q+fill_q;
avg_price = (base_p*base_q+fill_p*fill_q)/tot_qty;
}
else{
if(fill_q>=base_q){
tot_qty=0;
avg_price=0;
if(fill_q>base_q)
LOG(OrderMan,Error,"PositionServiceServer::_avg_price_qty "
"fill_id:{} base_qty:{} fill_qty:{}",
fill_id, base_q, fill_q);
}
else{
tot_qty=base_q-fill_q;
avg_price = (base_p*base_q-fill_p*fill_q)/tot_qty;
}
}
}
std::string PositionServiceServer::_fill_account(const Fill& fill){
return boost::trim_right_copy(fill.account());
}
PositionServiceServer::~PositionServiceServer(){
}
void PositionServiceServer::create_manual_fill(
const ManualFillBatch &batch,
const api::Response<PositionServiceResponse> &r)
{
PositionServiceResponse resp;
for (auto mf : batch.manual_fill()) {
auto id = utils::gen_id ("manual_fills");
mf.set_record_id(id);
me->manual_fills.insert({mf.record_id(), mf});
me->manual_fills_store->insert(manual_fills_ns,
std::to_string(id),
utils::pb::to_string(mf));
resp.add_response()->set_ok(true);
me->manual_fills_publisher.add_or_update(mf);
me->publisher.add_or_update(_on_fill(to_fill(mf),true));
}
r(resp);
me->manual_fills_publisher.flush();
me->publisher.flush();
}
void PositionServiceServer::update_manual_fill(
const ManualFillBatch &batch,
const api::Response<PositionServiceResponse> &r)
{
PositionServiceResponse resp;
for (auto mf : batch.manual_fill()) {
auto *this_resp = resp.add_response();
auto id = std::to_string(mf.record_id());
auto p = me->manual_fills_store->retrieve_one(manual_fills_ns,id);
auto found = p.first;
if (!found) {
this_resp->set_ok(false);
this_resp->set_msg("Could not find record");
}
else {
me->manual_fills_store->update(manual_fills_ns,
id,
utils::pb::to_string(mf));
this_resp->set_ok(true);
// Retrieve old record so we can remove it from position
auto it = me->manual_fills.find(mf.record_id());
bts_assert(it!= me->manual_fills.end());
auto &old = it->second;
// remove old
me->publisher.add_or_update(_on_fill(to_fill(old),false));
// add new
me->manual_fills.insert({mf.record_id(), mf});
me->publisher.add_or_update(_on_fill(to_fill(mf),true));
me->manual_fills_publisher.add_or_update(mf);
}
}
r(resp);
me->publisher.flush();
me->manual_fills_publisher.flush();
}
void PositionServiceServer::remove_manual_fill(
const ManualFillBatch &batch,
const api::Response<PositionServiceResponse> &r)
{
PositionServiceResponse resp;
for (auto mf : batch.manual_fill()) {
auto *this_resp = resp.add_response();
auto id = std::to_string(mf.record_id());
auto p = me->manual_fills_store->retrieve_one(manual_fills_ns,id);
auto found = p.first;
if (!found) {
this_resp->set_ok(false);
this_resp->set_msg("Could not find record");
}
else {
// Retrieve old record so we can remove it from position
auto it = me->manual_fills.find(mf.record_id());
bts_assert(it != me->manual_fills.end());
auto &old = it->second;
me->publisher.add_or_update(_on_fill(to_fill(old),false));
me->manual_fills.erase(it);
std::set<std::string> to_r ;
to_r.insert(id);
me->manual_fills_store->remove(manual_fills_ns,to_r);
this_resp->set_ok(true);
me->manual_fills_publisher.erase(mf.record_id());
}
}
r(resp);
me->publisher.flush();
me->manual_fills_publisher.flush();
}
void PositionServiceServer::_compute_pnl_and_publish(){
std::vector<const PositionUnit*> in_pos;
for (auto& acct_p : me->state) {
for (auto& sec_p : acct_p.second) {
const PositionUnit& pu = sec_p.second;
in_pos.push_back(&pu);
}
}
std::vector<PNLUnit> pnl;
std::vector<AccountPNL> account_pnl;
me->pnl_helper.compute_pnl(in_pos,pnl,account_pnl);
for (const auto& u : pnl)
me->pnl_publisher.add_or_update(u);
for (const auto& u : account_pnl)
me->pnl_account_publisher.add_or_update(u);
me->pnl_publisher.flush();
me->pnl_account_publisher.flush();
}
void PositionServiceServer::_periodic_poll(){
_compute_pnl_and_publish();
me->context.post([this](){_periodic_poll();},me->poll_period_ms);
}
}}