225 lines
7.5 KiB
C++
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
|