#include "PositionServiceServer.h" #include "lib/api/services/OrderService.pb.h" #include "lib/api/services/OrderService.client.pb.h" #include "lib/api/services/AdminService.pb.h" #include "lib/api/services/AdminService.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 #include #include #include #include #include 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; bts::api::admin::AdminService admin_service; std::map> state; std::map manual_fills; int id; PositionServicePNLHelper pnl_helper; int64_t poll_period_ms; // manual fills management std::unique_ptr manual_fills_store ; PositionServiceBase::Manual_fillsStatefulPublisher manual_fills_publisher; api::admin::AdminData admin_data; std::map account_map; 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()), admin_service(context.locate()), state(), id(0), pnl_helper(md_client), poll_period_ms(300), manual_fills_store(std::make_unique ("manual_fills")), manual_fills_publisher(manual_fills_publisher), admin_data(), account_map() { } }; 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( [this](auto const& update) { for (const auto& f : update.removed()) if(_valid_account_id(*f)) me->publisher.add_or_update(_on_fill(*f,false)); for (const auto& f : update.added()) if(_valid_account_id(*f)) me->publisher.add_or_update(_on_fill(*f,true)); for (const auto& f : update.changed()) { if(_valid_account_id(*f.previous()) && _valid_account_id(*f.current())){ 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->admin_service.subscribe_admin_data() | rxcpp::operators::subscribe( [this](auto const& update) { for (const auto& r : update.added()) {_set_admin_data(*r);} for (const auto& r : update.changed()) {_set_admin_data(*r.current());} }); 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(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){ PositionUnit& pu=_get_or_add(f); 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 Fill& f){ uint32_t account_id = f.internal_account_id(); uint32_t seckey = f.security_key(); auto &pu = me->state[account_id][seckey]; if (pu.record_id() == 0) { // new PU pu.set_record_id(++me->id); pu.set_security_id(seckey); pu.set_account_id(account_id); pu.set_account(f.account()); } 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()); } bool PositionServiceServer::_valid_account_id (const Fill& fill){ return fill.internal_account_id() != 0; } void PositionServiceServer::_set_admin_data(const api::admin::AdminData& admin_data){ me->admin_data = admin_data; for (const auto& a : admin_data.accounts()) me->account_map[a.name()] = a.id(); } PositionServiceServer::~PositionServiceServer(){ } void PositionServiceServer::create_manual_fill( const ManualFillBatch &batch, const api::Response &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 &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 &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 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 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 pnl; std::vector account_pnl; me->pnl_helper.compute_pnl(in_pos,me->account_map,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); } }}