295 lines
9.0 KiB
C++
295 lines
9.0 KiB
C++
#include "NativeOrderMan.h"
|
|
|
|
|
|
#include "lib/api/services/OrderService.pb.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/utils/PBUtils.h"
|
|
#include "lib/logging/logging.h"
|
|
#include "lib/domain_model/Security.h"
|
|
|
|
#include "server/sparkd/orderman/events/NativeOrderStateChange.h"
|
|
#include "server/sparkd/orderman/native_orders/NativeOrder.h"
|
|
#include "server/sparkd/orderman/utils/orderman_utils.h"
|
|
#include "server/sparkd/securities/SecurityDB.h"
|
|
#include "server/sparkd/orderman/events/OutGatewayMsg.h"
|
|
#include "server/sparkd/orderman/events/CreateNativeOrder.h"
|
|
#include "server/sparkd/orderman/events/UpdateNativeOrder.h"
|
|
#include "server/sparkd/orderman/events/CancelNativeOrder.h"
|
|
#include "server/sparkd/orderman/events/GatewayStatusChange.h"
|
|
#include "server/sparkd/orderman/events/ExecutionReport.h"
|
|
#include "server/sparkd/orderman/events/TimeChange.h"
|
|
#include "server/sparkd/orderman/events/CancelReject.h"
|
|
#include "server/sparkd/jetfix/common/OutFIX.h"
|
|
|
|
#include "lib/utils/datetime.h"
|
|
|
|
#include <boost/container/flat_map.hpp>
|
|
|
|
|
|
namespace bts {
|
|
namespace orderman {
|
|
|
|
using OrderMap = boost::container::flat_map<OrderKey, NativeOrderPtr>;
|
|
|
|
enum class NativeOrderMan::State {REPLAY,DISCONNECTED,CONNECTED};
|
|
|
|
struct NativeOrderMan::PImpl
|
|
{
|
|
PImpl(securities::SecurityDB &sec_db,
|
|
config::JetFIX::Connection const&jf_cfg,
|
|
Observer &obs) :
|
|
obs(obs),
|
|
state(State::REPLAY),
|
|
latest_timestamp(to<OrderTimeStamp> (datetime::FIX_timestamp(datetime::now()))),
|
|
order_map(),
|
|
sec_db(sec_db),
|
|
free_buffers(),
|
|
jf_cfg(jf_cfg)
|
|
|
|
{}
|
|
|
|
Observer &obs;
|
|
State state;
|
|
OrderTimeStamp latest_timestamp;
|
|
|
|
OrderMap order_map;
|
|
securities::SecurityDB &sec_db;
|
|
std::vector<jetfix::OutFIXPtr> free_buffers;
|
|
config::JetFIX::Connection jf_cfg;
|
|
};
|
|
|
|
NativeOrderMan::NativeOrderMan (securities::SecurityDB &sec_db,
|
|
std::vector<api::orderman::OrderState> const &existing_orders,
|
|
config::JetFIX::Connection const&gw_connection,
|
|
Observer &obs)
|
|
: me (new PImpl(sec_db,gw_connection,obs))
|
|
{
|
|
for (auto const &os : existing_orders)
|
|
if (os.has_native()) {
|
|
auto &native_state = os.native();
|
|
auto sk = SecurityKey(native_state.security_key());
|
|
auto sec = me->sec_db.resolve(sk);
|
|
if (sec)
|
|
me->order_map[OrderKey(os.order_key())] = std::make_unique<NativeOrder> (*sec,OrderKey(os.order_key()),native_state);
|
|
else {
|
|
LOG(OrderMan,Error,
|
|
"Cannot resolve security key {} in stored order {}. This is a serious problem. "
|
|
"This order will be ignored. Order details are: {}",
|
|
sk.value(),os.order_key(),utils::pb::to_string(os));
|
|
}
|
|
}
|
|
pre_allocate_buffers();
|
|
}
|
|
|
|
|
|
void NativeOrderMan::on(grid::event::Init const&)
|
|
{
|
|
LOG(OrderMan,Diag, "NativeOrderMan init");
|
|
|
|
bts_assert(me->state == State::REPLAY);
|
|
|
|
for (auto const &kvp : me->order_map) {
|
|
auto const &order = *kvp.second;
|
|
me->obs.on(event::NativeOrderStateChange {&order.header(),order._state});
|
|
}
|
|
}
|
|
|
|
void NativeOrderMan::on(event::CreateNativeOrder const&create)
|
|
{
|
|
|
|
auto &order = *create.order;
|
|
auto k = order.key();
|
|
|
|
LOG(OrderMan,Diag, "NativeOrderMan CreateNativeOrder {}",k.value());
|
|
|
|
auto &order_ptr = me->order_map[k];
|
|
|
|
if (order_ptr) {
|
|
LOG(OrderMan,Error,
|
|
"Someone tried to create a native order "
|
|
"using existing id {}. Order was for security: {}"
|
|
" This is a dangerous bug" ,
|
|
k.value(), securities::descriptor(*order._header.security));
|
|
return;
|
|
}
|
|
|
|
order_ptr.reset(&order);
|
|
|
|
switch (me->state) {
|
|
case State::REPLAY:
|
|
case State::DISCONNECTED:
|
|
order.mark_rejected_by_spark("Could not connect to the order gateway");
|
|
break;
|
|
case State::CONNECTED:
|
|
order.set_status (api::orderman::OS_UNACKNOWLEDGED);
|
|
auto buffer = get_fix_bufer();
|
|
order.encode_create(me->latest_timestamp,create.price,create.quantity,&buffer->fix[0]);
|
|
me->obs.on(event::OutGatewayMsg {buffer});
|
|
break;
|
|
}
|
|
|
|
me->obs.on(event::NativeOrderStateChange {&order.header(),order.state()});
|
|
}
|
|
|
|
void NativeOrderMan::on(event::UpdateNativeOrder const&update)
|
|
{
|
|
auto &order = *update.order;
|
|
|
|
LOG(OrderMan,Diag, "NativeOrderMan UpdateNativeOrder {}",order.key().value());
|
|
|
|
auto buffer = get_fix_bufer();
|
|
order.encode_update(me->latest_timestamp,update.price,update.quantity,&buffer->fix[0]);
|
|
me->obs.on(event::OutGatewayMsg {buffer});
|
|
}
|
|
|
|
void NativeOrderMan::on(event::CancelNativeOrder const&cancel)
|
|
{
|
|
auto &order = *cancel.order;
|
|
|
|
LOG(OrderMan,Diag, "NativeOrderMan CancelNativeOrder {}",order.key().value());
|
|
|
|
auto buffer = get_fix_bufer();
|
|
order.encode_cancel(me->latest_timestamp,&buffer->fix[0]);
|
|
me->obs.on(event::OutGatewayMsg {buffer});
|
|
}
|
|
|
|
void NativeOrderMan::on(event::GatewayStatusChange const&status)
|
|
{
|
|
LOG(OrderMan,Diag, "NativeOrderMan GatewayStatusChange {}",status.is_connected);
|
|
|
|
if (status.is_connected) {
|
|
switch (me->state) {
|
|
case State::REPLAY:
|
|
case State::CONNECTED:
|
|
bts_assert(false);
|
|
break;
|
|
case State::DISCONNECTED:
|
|
transition(State::CONNECTED);
|
|
break;
|
|
}
|
|
} else {
|
|
switch (me->state) {
|
|
case State::REPLAY:
|
|
case State::DISCONNECTED:
|
|
bts_assert(false);
|
|
break;
|
|
case State::CONNECTED:
|
|
transition(State::DISCONNECTED);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void NativeOrderMan::on(event::GatewayBeginReplay const&)
|
|
{
|
|
LOG(OrderMan,Diag, "NativeOrderMan GatewayBeginReplay");
|
|
|
|
bts_assert(me->state == State::REPLAY);
|
|
}
|
|
|
|
void NativeOrderMan::on(event::GatewayEndReplay const&)
|
|
{
|
|
LOG(OrderMan,Diag, "NativeOrderMan GatewayEndReplay");
|
|
|
|
bts_assert(me->state == State::REPLAY);
|
|
transition(State::DISCONNECTED);
|
|
}
|
|
|
|
void NativeOrderMan::on(event::ExecutionReport const&er)
|
|
{
|
|
auto k = er.order_key;
|
|
|
|
LOG(OrderMan,Diag, "NativeOrderMan ExecutionReport for order {}",k.value());
|
|
|
|
auto &order_ptr = me->order_map[k];
|
|
if (order_ptr)
|
|
order_ptr->on(er);
|
|
else {
|
|
LOG(OrderMan,Error,
|
|
"Received an execution report for an unknown order with key {} "
|
|
". Order state will be recovered from this report but fields "
|
|
"CustomerOrFirm and CTI code cannot be recovered and will be set "
|
|
"to the gateway's default values", k.value());
|
|
|
|
api::orderman::NativeOrderState recovered;
|
|
recovered.set_account_name(to_str(er.account_name));
|
|
recovered.set_operator_id(to_str(er.operator_id));
|
|
recovered.set_security_key(er.security->id());
|
|
recovered.set_side(er.side);
|
|
recovered.set_time_in_force(er.time_in_force);
|
|
recovered.set_order_type(er.order_type);
|
|
recovered.set_customer_or_firm(api::orderman::CustomerOrFirm(me->jf_cfg.customer_or_firm()));
|
|
recovered.set_cti_code (api::orderman::CTICode(me->jf_cfg.cti_code()[0]));
|
|
recovered.set_exchange_order_id(to_str(er.exchange_order_id));
|
|
recovered.set_manual_order_indicator(er.manual_order_indicator);
|
|
recovered.set_price(er.price.value());
|
|
recovered.set_order_quantity(er.order_quantity.value());
|
|
recovered.set_order_status(er.order_status);
|
|
recovered.set_avg_price(er.avg_price.value());
|
|
recovered.set_filled_quantity(er.filled_quantity.value());
|
|
recovered.set_reject_msg(er.reject_msg);
|
|
order_ptr = std::make_unique<NativeOrder>(*er.security,k,recovered);
|
|
}
|
|
me->obs.on(event::NativeOrderStateChange {&order_ptr->header(),order_ptr->state()});
|
|
}
|
|
|
|
void NativeOrderMan::on(event::CancelReject const&cr)
|
|
{
|
|
auto k = cr.order_key;
|
|
|
|
LOG(OrderMan,Diag, "NativeOrderMan CancelReject for order {}",k.value());
|
|
|
|
auto &order_ptr = me->order_map[k];
|
|
if (order_ptr) {
|
|
order_ptr->set_reject_msg(cr.reject_msg);
|
|
me->obs.on(event::NativeOrderStateChange {&order_ptr->header(),order_ptr->state()});
|
|
}
|
|
else
|
|
LOG(OrderMan,Error,
|
|
"Received a cancel reject for an unknown order with key {} "
|
|
"This should not happen and should be investigated", k.value());
|
|
}
|
|
|
|
void NativeOrderMan::on(event::TimeChange const&new_time)
|
|
{
|
|
me->latest_timestamp = new_time.ts_str ;
|
|
pre_allocate_buffers();
|
|
}
|
|
|
|
void NativeOrderMan::pre_allocate_buffers()
|
|
{
|
|
while (me->free_buffers.size() != 1000)
|
|
me->free_buffers.push_back(std::make_shared<jetfix::OutFIX>(me->jf_cfg));
|
|
}
|
|
|
|
jetfix::OutFIXPtr NativeOrderMan::get_fix_bufer()
|
|
{
|
|
if (me->free_buffers.empty())
|
|
pre_allocate_buffers();
|
|
|
|
auto back = me->free_buffers.back();
|
|
me->free_buffers.resize(me->free_buffers.size()-1);
|
|
return back;
|
|
}
|
|
|
|
const char* NativeOrderMan::state_name(State state)
|
|
{
|
|
switch (state) {
|
|
case State::REPLAY:
|
|
return "REPLAY";
|
|
case State::CONNECTED:
|
|
return "CONNECTED";
|
|
case State::DISCONNECTED:
|
|
return "DISCONNECTED";
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void NativeOrderMan::transition(State new_state)
|
|
{
|
|
LOG(OrderMan,Info,"Transitioning NativeOrderMan from {} to {}",
|
|
state_name(me->state),state_name(new_state));
|
|
}
|
|
|
|
}}
|