211 lines
7.1 KiB
C++
211 lines
7.1 KiB
C++
#include "OrderServiceServer.h"
|
|
#include "lib/api/public/ServiceContext.h"
|
|
#include "lib/api/services/AdminService.client.pb.h"
|
|
#include "lib/config/config.h"
|
|
#include "lib/config/protos/jetfix.pb.h"
|
|
#include "lib/utils/bts_chrono.h"
|
|
#include "server/sparkd/mercury/actors/Timer.h"
|
|
#include "server/sparkd/mercury/broker/AsyncEventBroker.h"
|
|
#include "server/sparkd/mercury/mercury_utils/Executor.h"
|
|
#include "server/sparkd/orderman/actors/AsyncFactory.h"
|
|
#include "server/sparkd/orderman/actors/ExecutionGateway.h"
|
|
#include "server/sparkd/orderman/actors/FillStore.h"
|
|
#include "server/sparkd/orderman/actors/MDSource.h"
|
|
#include "server/sparkd/orderman/actors/OrderStore.h"
|
|
#include "server/sparkd/orderman/actors/SecuritySrc.h"
|
|
#include "server/sparkd/orderman/actors/ServiceBridge.h"
|
|
#include "server/sparkd/orderman/actors/order_manager/OrderManager.h"
|
|
#include "lib/md/MDConsumer.h"
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
struct OrderServiceServer::PImpl {
|
|
PImpl(bts::api::ServiceContext &ctx, std::shared_ptr<api::ISyntheticSecurityService>& ss)
|
|
: fast_broker(std::make_shared<mercury::AsyncEventBroker>()),
|
|
slow_broker(std::make_shared<mercury::AsyncEventBroker>()),
|
|
service_bridge(), fast_exe(*fast_broker), slow_exe(*slow_broker),
|
|
fast_thread(), slow_thread(), service_ready(false), known_orders(),
|
|
known_fills(), publish_orders(), publish_fills(),
|
|
admin_service(ctx.locate<api::admin::AdminService>()),
|
|
md_consumer(ss) {}
|
|
|
|
std::shared_ptr<mercury::AsyncEventBroker> fast_broker;
|
|
std::shared_ptr<mercury::AsyncEventBroker> slow_broker;
|
|
std::shared_ptr<ServiceBridge> service_bridge;
|
|
mercury::Executor fast_exe;
|
|
mercury::Executor slow_exe;
|
|
std::thread fast_thread;
|
|
std::thread slow_thread;
|
|
std::atomic<bool> service_ready;
|
|
std::unordered_set<OrderKey> known_orders;
|
|
std::unordered_set<std::string> known_fills;
|
|
|
|
OrderServiceServer::OrdersPublisher publish_orders;
|
|
OrderServiceServer::FillsPublisher publish_fills;
|
|
api::admin::AdminService admin_service;
|
|
bts::md::MDConsumer md_consumer;
|
|
};
|
|
|
|
OrderServiceServer::OrderServiceServer(
|
|
bts::api::ServiceContext &ctx,
|
|
std::shared_ptr<api::ISyntheticSecurityService> &ss)
|
|
: api::orderman::OrderServiceBase(ctx), me(new PImpl(ctx, ss)) {
|
|
|
|
me->publish_orders = make_orders_publisher();
|
|
me->publish_fills = make_fills_publisher();
|
|
|
|
me->service_bridge = std::make_shared<ServiceBridge>(
|
|
[this]() { me->service_ready = true; },
|
|
|
|
[this, &ctx](auto const &orders) {
|
|
ctx.post([this, orders] { this->on_orders(orders); });
|
|
},
|
|
|
|
[this, &ctx](auto const &fill) {
|
|
ctx.post([this, fill] { this->on_fills(fill); });
|
|
});
|
|
|
|
me->fast_broker->init_neighbours({me->slow_broker});
|
|
me->slow_broker->init_neighbours({me->fast_broker});
|
|
|
|
// fast actors
|
|
me->fast_exe.spawn<MDSource>(me->md_consumer);
|
|
me->fast_exe.spawn<OrderManager>();
|
|
|
|
auto &all_connections = config::get<config::JetFIX>().connection();
|
|
for (auto const &c : all_connections)
|
|
me->fast_exe.spawn<ExecutionGateway>(c);
|
|
|
|
me->fast_thread = std::thread([this]() {
|
|
os::set_thread_name("fast_exe");
|
|
for (;;)
|
|
me->fast_exe.do_work();
|
|
});
|
|
|
|
// slow actors
|
|
me->slow_exe.activate(me->service_bridge);
|
|
me->slow_exe.spawn<mercury::Timer>();
|
|
me->slow_exe.spawn<AsyncFactory>();
|
|
me->slow_exe.spawn<OrderStore>();
|
|
me->slow_exe.spawn<FillStore>();
|
|
me->slow_exe.spawn<SecuritySrc>(me->md_consumer);
|
|
me->slow_thread = std::thread([this]() {
|
|
os::set_thread_name("slow_exe");
|
|
for (;;)
|
|
if (!me->slow_exe.do_work())
|
|
std::this_thread::sleep_for(10ms);
|
|
});
|
|
|
|
// wait for the service bridge to be ready
|
|
me->service_bridge->block_until_ready();
|
|
|
|
// subscribe to admin model updates and forward them to the service bridge
|
|
me->admin_service.subscribe_admin_data() |
|
|
rxcpp::operators::subscribe<api::admin::Admin_dataUpdate>(
|
|
[this](auto const &update) {
|
|
bts_assert(update.all().size() == 1);
|
|
me->service_bridge->update_admin_data(update.all()[0]);
|
|
});
|
|
}
|
|
|
|
OrderServiceServer::~OrderServiceServer() {
|
|
bts_assert(false); // this is badly broken at the moment
|
|
}
|
|
|
|
void OrderServiceServer::on_orders(
|
|
std::vector<api::orderman::OrderRecord> const &orders) {
|
|
LOG(OrderMan, Info, "Received order update for publishing");
|
|
std::vector<api::orderman::OrderRecord> created;
|
|
created.reserve(orders.size());
|
|
std::vector<api::orderman::OrderRecord> updated;
|
|
updated.reserve(orders.size());
|
|
|
|
for (auto const &rec : orders) {
|
|
auto const &k = OrderKey(rec.key());
|
|
if (me->known_orders.count(k) == 0) {
|
|
me->known_orders.insert(k);
|
|
created.push_back(rec);
|
|
} else
|
|
updated.push_back(rec);
|
|
}
|
|
|
|
LOG(OrderMan, Info,
|
|
"Publishing orders to the service API. Created {}, Updated {}",
|
|
created.size(), updated.size());
|
|
|
|
me->publish_orders(&created, &updated, nullptr);
|
|
}
|
|
|
|
void OrderServiceServer::on_fills(
|
|
std::vector<api::orderman::Fill const *> const &fills) {
|
|
LOG(OrderMan, Info, "Received fill update for publishing");
|
|
std::vector<api::orderman::Fill> created;
|
|
created.reserve(fills.size());
|
|
std::vector<api::orderman::Fill> updated;
|
|
updated.reserve(fills.size());
|
|
|
|
for (auto const &f : fills) {
|
|
auto const &k = f->fill_key();
|
|
if (me->known_fills.count(k) == 0) {
|
|
me->known_fills.insert(k);
|
|
created.push_back(*f);
|
|
} else
|
|
updated.push_back(*f);
|
|
}
|
|
|
|
me->publish_fills(&created, &updated, nullptr);
|
|
}
|
|
|
|
void OrderServiceServer::create_order(
|
|
const api::orderman::Create &c,
|
|
const api::Response<api::orderman::Response> &r) {
|
|
api::orderman::Response response;
|
|
if (!me->service_ready)
|
|
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
|
|
else
|
|
response = me->service_bridge->create_order(c);
|
|
r(response);
|
|
}
|
|
|
|
void OrderServiceServer::cancel_order(
|
|
const api::orderman::Cancel &cancel,
|
|
const api::Response<api::orderman::Response> &r) {
|
|
api::orderman::Response response;
|
|
response.set_order_key(cancel.order_key());
|
|
|
|
if (!me->service_ready)
|
|
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
|
|
else
|
|
response = me->service_bridge->cancel_order(cancel);
|
|
r(response);
|
|
}
|
|
|
|
void OrderServiceServer::update_order(
|
|
const api::orderman::Update &update,
|
|
const api::Response<api::orderman::Response> &r) {
|
|
api::orderman::Response response;
|
|
response.set_order_key(update.order_key());
|
|
|
|
if (!me->service_ready)
|
|
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
|
|
else
|
|
response = me->service_bridge->update_order(update);
|
|
r(response);
|
|
}
|
|
|
|
void OrderServiceServer::crack_order(
|
|
const api::orderman::Crack &crack,
|
|
const api::Response<api::orderman::Response> &r) {
|
|
api::orderman::Response response;
|
|
response.set_order_key(crack.order_key());
|
|
|
|
if (!me->service_ready)
|
|
response.set_error_code(api::orderman::ORDER_ERROR_SERVER_NOT_READY);
|
|
else
|
|
response = me->service_bridge->crack_order(crack);
|
|
r(response);
|
|
}
|
|
}
|
|
}
|