Files
spark/src/server/sparkd/orderman/components/NativeOrderMan.cpp
T
2017-09-25 20:18:28 +00:00

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));
}
}}