Files
spark/src/lib/orderman_v2/interconnect/Orchestrator.cpp
T
2019-11-15 09:03:51 -05:00

225 lines
7.5 KiB
C++

#include "lib/orderman_v2/interconnect/Orchestrator.h"
#include "lib/config/protos/orderman_cfg.pb.h"
#include "lib/md/MDConsumer.h"
#include "lib/orderman_v2/actors/Gateway.h"
#include "lib/orderman_v2/actors/MDSource.h"
#include "lib/orderman_v2/actors/OrderManager.h"
#include "lib/orderman_v2/actors/ServiceBridge.h"
#include "lib/orderman_v2/actors/Storage.h"
#include "Thread.h"
#include <fmt/format.h>
namespace bts {
namespace orderman_v2 {
struct Orchestrator::PImpl {
PImpl(md::MDConsumer &md) : md_consumer(md) {}
std::map<std::string, std::unique_ptr<Thread>> threads;
// All actors
Storage *storage = nullptr;
ServiceBridge *service_bridge = nullptr;
std::vector<std::pair<MDSource *, OrderManager *>> order_managers;
std::vector<Gateway *> gateways;
template <auto method> auto collect_om_fwds() {
using Arg = typename decltype(deduce_invoker(method))::Arg;
std::vector<Forwarder<Arg>> result;
for (auto p : order_managers)
result.push_back(fwd<method>(p.second));
return result;
}
template <auto method> auto collect_gw_fwds() {
using Arg = typename decltype(deduce_invoker(method))::Arg;
std::vector<Forwarder<Arg>> result;
for (auto gw : gateways)
result.push_back(fwd<method>(gw));
return result;
}
md::MDConsumer &md_consumer;
};
Orchestrator::Orchestrator(md::MDConsumer &md,
config::OrderManThreadingCfg const &cfg)
: me(new PImpl(md)) {
create_actors(cfg);
wire_actors();
}
void Orchestrator::create_actors(config::OrderManThreadingCfg const &cfg) {
for (auto const &t_cfg : cfg.thread()) {
auto thread =
get_thread(t_cfg.name(), t_cfg.poll(), t_cfg.slow_worker_period());
for (auto actor_desc : t_cfg.actor()) {
auto actor_name = actor_desc.name();
if (actor_name == "order_manager")
me->order_managers.push_back(
{thread->add_actor<MDSource>(me->md_consumer),
thread->add_actor<OrderManager>()});
else if (actor_name == "gateway")
me->gateways.push_back(
thread->add_actor<Gateway>(actor_desc.arg(0)));
else if (actor_name == "storage") {
bts_assert_msg(!me->storage,
"Duplicate storage actor in OrderManThreadingCfg");
me->storage = thread->add_actor<Storage>();
} else if (actor_name == "service_bridge") {
bts_assert_msg(
!me->service_bridge,
"Duplicate service_bridge actor in OrderManThreadingCfg");
me->service_bridge = thread->add_actor<ServiceBridge>();
} else
bts_assert_msg(
false, fmt::format(
"Unknown actor {} specified in OrderManThreadingCfg",
actor_name));
}
}
bts_assert_msg(me->threads.size(),
"OrderManThreadingCfg should define at least one thread");
bts_assert_msg(
me->service_bridge,
"OrderManThreadingCfg should define one service_bridge actor");
bts_assert_msg(me->storage,
"OrderManThreadingCfg should define one storage actor");
bts_assert_msg(
me->order_managers.size(),
"OrderManThreadingCfg should define at least one order_manager actor");
bts_assert_msg(
me->gateways.size(),
"OrderManThreadingCfg should define at least one gateway actor");
}
void Orchestrator::wire_actors() {
wire_storage();
wire_service_bridge();
wire_order_managers();
wire_gateways();
}
void Orchestrator::wire_storage() {
auto store = me->storage;
auto sb = me->service_bridge;
// boot strap orders
store->on_bootstrap_orders.broadcast_to(
me->collect_om_fwds<&OrderManager::on_bootstrap_orders>());
// boot strap fills
store->on_bootstrap_fills.forward_to<&ServiceBridge::on_bootstrap_fills>(sb);
// new stored order
store->on_new_stored_order.forward_to<&ServiceBridge::on_new_stored_order>(
sb);
// new stored fill
store->on_new_stored_fill.forward_to<&ServiceBridge::on_new_stored_fill>(sb);
}
void Orchestrator::wire_service_bridge() {
auto sb = me->service_bridge;
// CreateOrderRequest
sb->on_create_order.route_to(
[](auto const &r) { return r.target.value; },
me->collect_om_fwds<&OrderManager::on_create_order>());
// UpdateOrderRequest
sb->on_update_order.route_to(
[](auto const &r) { return r.target.value; },
me->collect_om_fwds<&OrderManager::on_update_order>());
// CancelOrderRequest
sb->on_cancel_order.route_to(
[](auto const &r) { return r.target.value; },
me->collect_om_fwds<&OrderManager::on_cancel_order>());
// DetachOrderRequest
sb->on_detach_order.route_to(
[](auto const &r) { return r.target.value; },
me->collect_om_fwds<&OrderManager::on_detach_order>());
// AdminDataUpdate
auto admin_fwds = me->collect_om_fwds<&OrderManager::on_admin_data>();
auto gw_admin_fwds = me->collect_gw_fwds<&Gateway::on_admin_data>();
admin_fwds.insert(admin_fwds.end(), gw_admin_fwds.begin(),
gw_admin_fwds.end());
sb->on_admin_data.broadcast_to(admin_fwds);
// ExcessLiquidityUpdate
sb->on_excess_liquidity.broadcast_to(
me->collect_gw_fwds<&Gateway::on_excess_liquidity>());
// AccountPnLUpdate
sb->on_account_pnl.broadcast_to(
me->collect_gw_fwds<&Gateway::on_account_pnl>());
// PositionUpdate
sb->on_position.broadcast_to(me->collect_gw_fwds<&Gateway::on_position>());
}
void Orchestrator::wire_order_managers() {
for (auto [md, om] : me->order_managers) {
// md req/reply
md->on_book.forward_to<&OrderManager::on_book>(om);
md->on_ticker.forward_to<&OrderManager::on_ticker>(om);
md->on_sec_status.forward_to<&OrderManager::on_sec_status>(om);
om->on_md_request.forward_to<&MDSource::on_md_request>(md);
// GW_op
om->on_gw_op.route_to([](const auto &op) { return op.target.value; },
me->collect_gw_fwds<&Gateway::on_gw_ops>());
// OM_OrderUpdate
om->on_order_update.forward_to<&Storage::on_order_update>(me->storage);
// OM_Reply
om->on_om_reply.forward_to<&ServiceBridge::on_om_reply>(
me->service_bridge);
// OM_BootStrapOrder
om->on_om_bootstrap_orders.route_to(
[](const auto &o) { return o.target.value; },
me->collect_gw_fwds<&Gateway::on_om_bootstrap_orders>());
}
}
void Orchestrator::wire_gateways() {
for (auto gw : me->gateways) {
// GW_OrderUpdate
gw->on_native_order_update.route_to(
[](auto const &o) { return o.target.value; },
me->collect_om_fwds<&OrderManager::on_native_order_update>());
// Route unknown native order updates to the first order manager
// only
gw->on_unknown_native_order_update
.forward_to<&OrderManager::on_unknown_native_order_update>(
me->order_managers[0].second);
// Route errors to the service bridge for display in the
// UI. Invidual order manager will get order specific updates
// when a gateway disconnects
gw->on_gw_error.forward_to<&ServiceBridge::on_gw_error>(
me->service_bridge);
}
}
Thread *Orchestrator::get_thread(std::string const &name, bool poll,
uint32_t slow_worker_period) {
auto &thread = me->threads[name];
if (!thread)
thread = std::make_unique<Thread>(name, poll, slow_worker_period);
return thread.get();
}
} // namespace orderman_v2
} // namespace bts