#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 #include #include #include #include #include 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 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 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()), pos_publisher(pos_publisher), // manual fills manual_fills_store( std::make_unique("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()), 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( [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( [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(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 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(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 void _diff (const std::map& new_state, const std::map& prev_state, std::vector& added, std::vector& updated, std::vector& 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 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 &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 &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 &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 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&) { 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 in_pos; me->state.get_pos(in_pos); 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); } PositionServiceServer::~PositionServiceServer() {} } // namespace position } // namespace bts