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

321 lines
12 KiB
C++

#include "PositionServiceServer.h"
#include "PositionServicePNLHelper.h"
#include "lib/api/public/ServiceContext.h"
#include "lib/api/service_helpers/AdminServiceUtils.h"
#include "lib/api/service_helpers/PositionUtilities.h"
#include "lib/api/services/AdminService.client.pb.h"
#include "lib/api/services/AdminService.pb.h"
#include "lib/api/services/OrderService.client.pb.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/logging/logging.h"
#include "lib/orderman/actors/SODPosition.h"
#include "lib/persistence/SqliteStore.h"
#include "lib/utils/PBUtils.h"
#include "lib/utils/Puid.h"
#include "PositionMap.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::md;
static auto const manual_fills_ns = "manual_fills";
struct PositionServiceServer::PImpl {
bts::orderman::PositionMap state;
bts::api::ServiceContext &context;
bts::api::orderman::OrderService order_service;
PositionServiceBase::Position_dataStatefulPublisher pos_publisher;
int id;
// manual fills management
std::unique_ptr<persistence::IStore> manual_fills_store;
PositionServiceBase::Manual_fillsStatefulPublisher manual_fills_publisher;
// pnl
PositionServiceBase::Pnl_dataStatefulPublisher pnl_publisher;
PositionServiceBase::Pnl_account_dataStatefulPublisher pnl_account_publisher;
PositionServicePNLHelper pnl_helper;
int64_t poll_period_ms;
// admin data needed for pnl
bts::api::admin::AdminService admin_service;
api::admin::AdminData admin_data;
std::map<std::string, uint32_t> account_map;
PImpl(
bts::api::ServiceContext &context,
const PositionServiceBase::Position_dataStatefulPublisher &pos_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)
: // pos
context(context),
order_service(context.locate<bts::api::orderman::OrderService>()),
pos_publisher(pos_publisher),
// manual fills
manual_fills_store(
std::make_unique<persistence::SqliteStore>("manual_fills")),
manual_fills_publisher(manual_fills_publisher),
// pnl
pnl_publisher(pnl_publisher),
pnl_account_publisher(pnl_account_publisher),
pnl_helper(md_client),
poll_period_ms(300),
// admin
admin_service(context.locate<bts::api::admin::AdminService>()),
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)) {
_delete_presod_local_on_start();
// incremental fill update
me->order_service.subscribe_fills() |
rxcpp::operators::subscribe<api::orderman::FillsUpdate>(
[this](auto const &update) {
for (const auto &f : update.removed())
me->pos_publisher.add_or_update(_on_fill(*f, false));
for (const auto &f : update.added())
me->pos_publisher.add_or_update(_on_fill(*f, true));
for (const auto &f : update.changed()) {
me->pos_publisher.add_or_update(_on_fill(*f.previous(), false));
me->pos_publisher.add_or_update(_on_fill(*f.current(), true));
}
me->pos_publisher.flush();
_compute_pnl_and_publish();
}
);
// admin data
me->admin_service.subscribe_admin_data() |
rxcpp::operators::subscribe<api::admin::Admin_dataUpdate>(
[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());
});
// manual fills
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_publisher.add_or_update(rec);
me->pos_publisher.add_or_update(_on_manual_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->pos_publisher.flush();
me->context.post([this]() { _periodic_poll(); }, me->poll_period_ms);
}
void PositionServiceServer::_delete_presod_local_on_start() const{
std::set<std::string> rm_ids;
auto all = me->manual_fills_store->retrieve_all()[manual_fills_ns];
ManualFill rec;
for (auto const &kvp : all){
if (utils::pb::from_string<ManualFill>(kvp.second, &rec)) {
if(rec.fill_type() == ManualFill::LOCAL &&
me->state.is_sod(rec.timestamp())){
LOG(OrderMan, Info,
"PositionServiceServer::_delete_presod_local_on_start "
"fill: {}", kvp.second);
auto id = std::to_string(rec.record_id());
rm_ids.insert(id);
}
}
else
LOG(OrderMan, Error,
"Could not recover manual fill {} from storage. "
"This should be investigated",
kvp.first);
}
me->manual_fills_store->remove(manual_fills_ns, rm_ids);
}
const PositionUnit &PositionServiceServer::_on_fill(const Fill &f,
bool is_add) {
return me->state.on_fill(f,is_add);
}
const PositionUnit &PositionServiceServer::_on_manual_fill(const ManualFill &mf,
bool is_add) {
return me->state.on_manual_fill(mf,is_add);
}
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();
me->state.set_admin_data(admin_data);
_clear_and_publish_pos();
}
template <class T, class TKey>
void _diff (const std::map<TKey, T const*>& new_state,
const std::map<TKey, T const*>& prev_state,
std::vector<T const*>& added,
std::vector<T const*>& updated,
std::vector<T const*>& deleted){
for (const auto& p : new_state){
if(prev_state.find(p.first)==prev_state.end())
added.push_back(p.second);
else
updated.push_back(p.second);
}
for (const auto& p : prev_state)
if(new_state.find(p.first)==new_state.end())
deleted.push_back(p.second);
}
void PositionServiceServer::_clear_and_publish_pos(){
std::map<int, PositionUnit const*> new_state;
me->state.get_pos (new_state);
// entries are never deleted from new_state
for (const auto& p : new_state)
me->pos_publisher.add_or_update(*p.second);
me->pos_publisher.flush();
}
///////////////////////////////////////////////////////////////////////////////
/// Manual Fills API //////////////////////////////////////////////////////////
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);
struct timeval tv;
gettimeofday(&tv, NULL);
mf.mutable_timestamp()->set_seconds(tv.tv_sec);
mf.mutable_timestamp()->set_nanos(tv.tv_usec * 1000);
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->pos_publisher.add_or_update(_on_manual_fill(mf, true));
}
r(resp);
me->manual_fills_publisher.flush();
me->pos_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
ManualFill const* old_ptr = me->state.get_manual_fill(mf.record_id());
bts_assert(old_ptr != nullptr);
// remove old
me->pos_publisher.add_or_update(_on_manual_fill(*old_ptr, false));
// add new
me->pos_publisher.add_or_update(_on_manual_fill(mf, true));
me->manual_fills_publisher.add_or_update(mf);
}
}
r(resp);
me->pos_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
ManualFill const* old_ptr = me->state.get_manual_fill(mf.record_id());
bts_assert(old_ptr != nullptr);
me->pos_publisher.add_or_update(_on_manual_fill(*old_ptr, false));
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->pos_publisher.flush();
me->manual_fills_publisher.flush();
}
void PositionServiceServer::set_base_position(
const BasePositionBatch& req,
const api::Response<SetBasePositionResponse>&) {
LOG(persist, Info, "PositionServiceServer::set_base_position bp count:{}",
req.positions_size());
me->state.set_base_position(req);
_clear_and_publish_pos();
}
///////////////////////////////////////////////////////////////////////////////
/// PNL helpers ///////////////////////////////////////////////////////////////
void PositionServiceServer::_compute_pnl_and_publish() {
std::map<int, PositionUnit const*> in_pos;
me->state.get_pos(in_pos);
std::vector<PNLUnit> pnl;
std::vector<AccountPNL> 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);
}
PositionServiceServer::~PositionServiceServer() {}
} // namespace position
} // namespace bts