Files
spark/src/server/sparkd/orderman2/actors/ExecutionGateway.cpp
T

227 lines
8.3 KiB
C++

#include "ExecutionGateway.h"
#include "lib/utils/TimeStamp.h"
#include "server/sparkd/jetfix/codec/MessageDefinitions.h"
#include "server/sparkd/jetfix/gateway/JetFIXGateway.h"
#include "server/sparkd/orderman2/events/CancelRejectEvent.h"
#include "server/sparkd/orderman2/events/GatewayStatusChangeEvent.h"
#include "server/sparkd/orderman2/events/NewExecutionReportEvent.h"
#include "server/sparkd/orderman2/events/NewSecuritiesEvent.h"
#include "server/sparkd/orderman2/orderman2_utils/fix_order_codec.h"
#include "lib/logging/logging.h"
#include <boost/pool/object_pool.hpp>
namespace bts {
namespace orderman2 {
using namespace jetfix;
using JFGw =
JetFIXGateway<fix::ExecutionReportMsg, fix::BusinessMessageRejectMsg,
fix::RejectMsg, fix::CancelRejectMsg>;
struct ExecutionGateway::PImpl {
PImpl(config::JetFIX::Connection const &cfg)
: gw(cfg), exe_report_pool(), state(State::WAITING_FOR_SECURITIES),
securities(), exe_report_stream(), gw_status_change_stream(),
cancel_reject_stream(), gw_name(cfg.name()), cfg(cfg) {}
JFGw gw;
boost::object_pool<ExecutionReport> exe_report_pool;
State state;
std::unordered_map<SecurityKey::Value, api::Security const *> securities;
mercury::Stream<NewExecutionReportEvent> exe_report_stream;
mercury::Stream<GatewayStatusChangeEvent> gw_status_change_stream;
mercury::Stream<CancelRejectEvent> cancel_reject_stream;
GatewayName gw_name;
config::JetFIX::Connection cfg;
};
ExecutionGateway::ExecutionGateway(config::JetFIX::Connection const &cfg)
: me(new PImpl(cfg)) {}
ExecutionGateway::~ExecutionGateway() {}
void ExecutionGateway::init() {
me->state = State::WAITING_FOR_SECURITIES;
subscribe<NewSecuritiesEvent>(
[this](auto const &sec_update) { this->on_securities(sec_update); });
subscribe<OutFIXMsgEvent>(
me->gw_name, [this](auto const &fix) { this->on_outgoing_fix(fix); });
}
void ExecutionGateway::on_securities(
const mercury::Update<NewSecuritiesEvent> &update) {
if (update.events) {
for (auto const &ev : *(update.events)) {
auto sec_ptr = ev.security;
me->securities[sec_ptr->id()] = sec_ptr;
}
if (me->state == State::WAITING_FOR_SECURITIES) {
LOG(OrderMan, Warn, "Received first set of {} securities. Proceeding "
"with initialization of execution gateway {}",
update.events->size(), me->gw_name.value());
// got our security synopsis, ready to start the GW
me->state = State::READY;
// subscribe to gateway events
me->gw.on<fix::ExecutionReportMsg>() = [this](auto const &msg) {
this->on_exe_report(msg);
};
me->gw.on<fix::CancelRejectMsg>() = [this](auto const &msg) {
this->on_cancel_reject(msg);
};
me->gw.on_ready() = [this]() {
this->on_connection_status_change(true);
};
me->gw.on_disconnect() = [this]() {
this->on_connection_status_change(false);
};
me->gw.on<fix::BusinessMessageRejectMsg>() = [this](auto const &m) {
this->on_business_reject(m);
};
me->gw.on<fix::RejectMsg>() = [this](auto const &m) {
this->on_session_reject(m);
};
// stream of execution reports
me->exe_report_stream =
make_stream<NewExecutionReportEvent>(me->gw_name);
// stream for gateway status
me->gw_status_change_stream =
make_stream<GatewayStatusChangeEvent>(me->gw_name);
// stream for cancel rejects
me->cancel_reject_stream = make_stream<CancelRejectEvent>(me->gw_name);
// start the gateway
me->gw.start();
}
}
}
void ExecutionGateway::on_exe_report(
const jetfix::fix::ExecutionReportMsg &msg) {
OrderKey ok;
SecurityKey sk;
decode_clorid(msg.get<fix::ClOrdID>(), &ok, &sk);
auto sec = me->securities[sk.value()];
if (!sec)
LOG(OrderMan, Error,
"Received execution report for an unknown security {}. Will not be "
" able to process this report. This is likely a bug that could lead "
"to"
" lost fills. Please investigate.",
sk.value());
else {
// ignore leg fills, we care only about the actual security fill
if (msg.has<fix::MultiLegReportingType>() &&
msg.get<fix::MultiLegReportingType>() == 2)
return;
std::string text_msg;
if (msg.has<fix::Text>())
text_msg = msg.get<fix::Text>();
// allocate from our pool
auto data = me->exe_report_pool.construct();
// copy data from fix msg to our structure
str_to(msg.get<fix::Account>(), &data->account_name);
str_to(msg.get<fix::TargetSubID>(), &data->operator_id);
data->order_key = ok;
data->security = sec;
data->side = api::Side(msg.get<fix::Side>());
data->time_in_force =
api::orderman2::TimeInForce(msg.get<fix::TimeInForce>());
data->order_type =
api::orderman2::NativeOrderType(msg.get<fix::OrdType>());
data->exec_type = api::orderman2::ExecType(msg.get<fix::ExecType>());
data->order_status =
api::orderman2::NativeOrderStatus(msg.get<fix::OrdStatus>());
data->manual_order_indicator =
msg.get<fix::ManualOrderIndicator>()
? api::orderman2::MANUAL_ORDER_INDICATOR_YES
: api::orderman2::MANUAL_ORDER_INDICATOR_YES;
str_to(msg.get<fix::OrderID>(), &data->exchange_order_id);
data->price =
securities::decode_exchange_price(*sec, Price(msg.get<fix::Price>()));
data->quantity = Quantity(msg.get<fix::OrderQty>());
data->filled_quantity = Quantity(msg.get<fix::CumQty>());
data->last_shares = msg.has<fix::LastShares>()
? Quantity(msg.get<fix::LastShares>())
: Quantity(0);
data->last_price = msg.has<fix::LastPx>()
? securities::decode_exchange_price(
*sec, Price(msg.get<fix::LastPx>()))
: Price(0);
data->avg_price = msg.has<fix::AvgPx>()
? securities::decode_exchange_price(
*sec, Price(msg.get<fix::AvgPx>()))
: Price(0);
str_to(msg.get<fix::ExecID>(), &data->exchange_fill_id);
str_to(msg.get<fix::TransactTimeStr>(), &data->transact_time);
data->cfg = &me->cfg;
data->msg = text_msg;
publish(me->exe_report_stream, data);
}
}
void ExecutionGateway::on_cancel_reject(
const jetfix::fix::CancelRejectMsg &msg) {
OrderKey ok;
SecurityKey sk;
decode_clorid(msg.get<fix::ClOrdID>(), &ok, &sk);
std::string reject_msg;
if (msg.has<fix::Text>())
reject_msg = msg.get<fix::Text>();
else if (msg.has<fix::CXlRejReason>())
reject_msg = fmt::format("Order cancel was rejected with error code {}",
msg.get<fix::CXlRejReason>());
publish(me->cancel_reject_stream, ok, reject_msg);
}
void ExecutionGateway::on_connection_status_change(bool is_connected) {
LOG(OrderMan, Info, "Connection state of {} changed to {}",
me->gw_name.value(),
is_connected ? std::string("connected") : std::string("disconnected"));
publish(me->gw_status_change_stream, is_connected);
}
void ExecutionGateway::on_business_reject(
jetfix::fix::BusinessMessageRejectMsg const &m) {
LOG(OrderMan, Error, "Unexpected business reject in {} gateway . Reason: "
"{}. This should be investigated",
me->gw_name.value(),
m.has<fix::Text>() ? m.get<fix::Text>() : std::string("Unknown"));
}
void ExecutionGateway::on_session_reject(jetfix::fix::RejectMsg const &m) {
LOG(OrderMan, Error, "Unexpected reject message in {} gateway . Reason: {}. "
"This should be investigated",
me->gw_name.value(),
m.has<fix::Text>() ? m.get<fix::Text>() : std::string("Unknown"));
}
void ExecutionGateway::on_poll() { me->gw.dispatch_events(); }
void ExecutionGateway::on_outgoing_fix(
mercury::Update<OutFIXMsgEvent> const &msg) {
if (msg.events)
for (auto const &ev : *(msg.events)) {
LOG(Latency, Info, "Gateway {} {}", ev.cid,
utils::TimeStamp::now().to_uint64());
me->gw.send(ev.cid, ev.msg);
}
}
}
}