Merge branch 'master' of bitbucket.org:bluetradesys/spark

This commit is contained in:
Kevin Darby committed 2017-10-05 09:36:08 -04:00
commit 47738cb215
30 files changed
+889 -232

No files matched your search

+17 -8
View File
@@ -141,6 +141,8 @@ message NativeOrderState {
message SpreaderOrderState {
double target_price = 1;
uint32 target_quantity = 2 ;
string account_name = 3;
string operator_id = 4;
}
message OrderState {
@@ -172,14 +174,20 @@ message CreateNativeOrder{
uint32 quantity = 13;
}
message CreateSpreaderOrder {}
message CreateSpreaderOrder {
string account_name = 1;
string operator_id = 2;
double price = 3;
uint32 quantity = 4;
api.BuySell side = 5;
}
message CreateOrderRequest {
google.protobuf.Timestamp timestamp = 1;
orderman.CustomerOrFirm customer_or_firm = 8;
orderman.CTICode cti_code = 9;
oneof create {
CreateNativeOrder native_order = 2;
CreateNativeOrder native = 2;
CreateSpreaderOrder spreader = 3;
}
}
@@ -189,27 +197,28 @@ message UpdateNativeOrder {
uint32 quantity = 13;
}
message UpdateSpreaderOrder {}
message UpdateSpreaderOrder {
double price = 12;
uint32 quantity = 13;
}
message UpdateOrderRequest {
uint32 order_key = 1;
google.protobuf.Timestamp timestamp = 2;
oneof update {
UpdateNativeOrder native_order = 3;
UpdateNativeOrder native = 3;
UpdateSpreaderOrder spreader = 4;
}
}
message CancelNativeOrder {
}
message CancelNativeOrder {}
message CancelSpreaderOrder {}
message CancelOrderRequest {
uint32 order_key = 1;
google.protobuf.Timestamp timestamp = 2;
oneof cancel {
CancelNativeOrder native_order = 3;
CancelNativeOrder native = 3;
CancelSpreaderOrder spreader = 4;
}
}
+1 -1
View File
@@ -1 +1 @@
set(sources ;cmds/CmdRegistry.cpp;cmds/Help.cpp;cmds/Run.cpp;cmds/Test.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;orderman/components/FillRecorder.cpp;orderman/components/Gateway.cpp;orderman/components/MDSource.cpp;orderman/components/NativeOrderMan.cpp;orderman/components/OrderRecorder.cpp;orderman/components/SpreaderOrderMan.cpp;orderman/events/ExecutionReport.cpp;orderman/events/NativeOrderStateChange.cpp;orderman/events/TimeChange.cpp;orderman/native_orders/NativeOrder.cpp;orderman/native_orders/NativeOrderBuilder.cpp;orderman/persistence/FillDB.cpp;orderman/persistence/OrderDB.cpp;orderman/persistence/gen_order_id.cpp;orderman/service/OrderServiceServer.cpp;orderman/spreader_orders/SpreaderOrder.cpp;orderman/utils/fix_order_codec.cpp;orderman/utils/orderman_utils.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;risk_limits/IRiskLimitObserver.cpp;risk_limits/RiskLimitManager.cpp;risk_limits/RiskLimiter.cpp;risk_limits/SharedRiskLimiter.cpp;risk_limits/SymbolKey.cpp;risk_limits/tests/RiskLimitsTests.cpp;securities/SecurityDB.cpp;spreader/QuoteLegPriceQuantityState.cpp;spreader/SimpleSpreader.cpp;spreader/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/SpreaderBase.cpp;spreader/SpreaderTests.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp)
set(sources ;cmds/CmdRegistry.cpp;cmds/Help.cpp;cmds/Run.cpp;cmds/Test.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;orderman/components/FillRecorder.cpp;orderman/components/Gateway.cpp;orderman/components/MDSource.cpp;orderman/components/NativeOrderMan.cpp;orderman/components/OrderRecorder.cpp;orderman/components/SpreaderOrderMan.cpp;orderman/events/ExecutionReport.cpp;orderman/events/NativeOrderStateChange.cpp;orderman/events/SpreaderOrderStateChange.cpp;orderman/events/TimeChange.cpp;orderman/native_orders/NativeOrder.cpp;orderman/native_orders/NativeOrderBuilder.cpp;orderman/native_orders/NativeOrderFactory.cpp;orderman/persistence/FillDB.cpp;orderman/persistence/OrderDB.cpp;orderman/persistence/gen_order_id.cpp;orderman/service/OrderServiceServer.cpp;orderman/spreader_orders/SpreaderOrder.cpp;orderman/spreader_orders/SpreaderOrderBase.cpp;orderman/utils/fix_order_codec.cpp;orderman/utils/orderman_utils.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;risk_limits/IRiskLimitObserver.cpp;risk_limits/RiskLimitManager.cpp;risk_limits/RiskLimiter.cpp;risk_limits/SharedRiskLimiter.cpp;risk_limits/SymbolKey.cpp;risk_limits/tests/RiskLimitsTests.cpp;securities/SecurityDB.cpp;spreader/QuoteLegPriceQuantityState.cpp;spreader/SimpleSpreader.cpp;spreader/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/SpreaderBase.cpp;spreader/SpreaderTests.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp)
+3 -3
View File
@@ -29,7 +29,7 @@ api::orderman::CreateOrderRequest make_create_request(SecurityKey sec, api::BuyS
*result.mutable_timestamp() = utils::pb::to_timestamp(datetime::now());
result.set_customer_or_firm(api::orderman::COF_FIRM);
result.set_cti_code(api::orderman::CTI_CTI1);
auto &native = *result.mutable_native_order();
auto &native = *result.mutable_native();
native.set_account_name("BTS");
native.set_operator_id("BTS");
native.set_security_key(sec.value());
@@ -48,7 +48,7 @@ api::orderman::UpdateOrderRequest make_update_request(OrderKey k, Price price, Q
result.set_order_key(k.value());
*result.mutable_timestamp() = utils::pb::to_timestamp(datetime::now());
auto &native = *result.mutable_native_order();
auto &native = *result.mutable_native();
native.set_price(price.value());
native.set_quantity(quantity.value());
return result;
@@ -59,7 +59,7 @@ api::orderman::CancelOrderRequest make_cancel_request(OrderKey k)
api::orderman::CancelOrderRequest result;
result.set_order_key(k.value());
*result.mutable_timestamp() = utils::pb::to_timestamp(datetime::now());
result.mutable_native_order();
result.mutable_native();
return result;
}
@@ -0,0 +1,11 @@
#pragma once
#include <memory>
namespace bts {
namespace event_grid {
template <class Event>
using Signal = std::function<void(const Event&)>;
}}
@@ -1,6 +1,7 @@
#pragma once
#include <memory>
#include "server/sparkd/event_grid/event_grid_utils.h"
namespace bts {
namespace event_grid {namespace event {class Init;}}
@@ -20,7 +21,7 @@ public:
void on(event_grid::event::Init const&);
// out
std::function<void(event::NativeFills const&)> native_fill_signal;
event_grid::Signal<event::NativeFills> native_fill_signal;
private:
struct PImpl;
@@ -7,6 +7,8 @@
#include "server/sparkd/orderman/service/OrderServiceServer.h"
#include "server/sparkd/orderman/utils/orderman_utils.h"
#include "server/sparkd/orderman/events/ExecutionReport.h"
#include "server/sparkd/event_grid/events/Init.h"
#include "server/sparkd/event_grid/event_grid_utils.h"
#include <fmt/format.h>
@@ -32,12 +34,11 @@ public:
void on(event::OutGatewayMsg const&m) {_gw.send(m.msg);}
// out
std::function<void(event::ExecutionReport const&)> execution_report_signal;
std::function<void(event::CancelReject const&)> cancel_reject_signal;
std::function<void(event::GatewayStatusChange const&)> gateway_status_change_signal;
std::function<void(event::GatewayBeginReplay const&)> gateway_begin_replay_signal;
std::function<void(event::GatewayEndReplay const&)> gateway_end_replay_signal;
event_grid::Signal<event::ExecutionReport> execution_report_signal;
event_grid::Signal<event::CancelReject> cancel_reject_signal;
event_grid::Signal<event::GatewayStatusChange> gateway_status_change_signal;
event_grid::Signal<event::GatewayBeginReplay> gateway_begin_replay_signal;
event_grid::Signal<event::GatewayEndReplay> gateway_end_replay_signal;
private:
using FIXGw = jetfix::JetFIXGateway<jetfix::fix::ExecutionReportMsg,
@@ -5,6 +5,7 @@
#include "lib/md/MDConsumerHandle.h"
#include "lib/md/MDRecoverableConsumer.h"
#include "server/sparkd/orderman/events/MDSubscription.h"
#include "server/sparkd/event_grid/event_grid_utils.h"
namespace bts {
namespace orderman {
@@ -16,9 +17,12 @@ public:
void on(event::MDSubscription const&sub)
{
auto k = sub.for_security->id();
for (auto &h : _handles)
if (h.handle->key() == k)
if (h.handle->key() == k) {
h.last = utils::TimeStamp();
return ;
}
auto managed_handle = _md_consumer.get_managed_handle(k);
_keep_alive.push_back(managed_handle);
@@ -26,7 +30,7 @@ public:
}
// out
std::function<void(event::BookUpdate const&)> book_update_signal;
event_grid::Signal<event::BookUpdate> book_update_signal;
MDSource() : book_update_signal([](auto){}), _handles(),_md_consumer(),_keep_alive() {}
@@ -51,7 +55,6 @@ private:
md2::MDConsumerHandle* handle;
};
std::vector<HandleRecord> _handles;
md::MDRecoverableConsumer _md_consumer;
std::vector<std::shared_ptr<md2::MDConsumerHandle>> _keep_alive;
@@ -21,6 +21,7 @@
#include "server/sparkd/orderman/events/CancelReject.h"
#include "server/sparkd/jetfix/common/OutFIX.h"
#include "server/sparkd/orderman/persistence/gen_order_id.h"
#include "server/sparkd/orderman/native_orders/NativeOrderFactory.h"
#include "lib/utils/datetime.h"
@@ -30,21 +31,22 @@
namespace bts {
namespace orderman {
using OrderMap = boost::container::flat_map<OrderKey, NativeOrderPtr>;
using OrderMap = boost::container::flat_map<OrderKey, NativeOrder*>;
enum class NativeOrderMan::State {REPLAY,DISCONNECTED,CONNECTED};
struct NativeOrderMan::PImpl
{
PImpl(config::JetFIX::Connection const&jf_cfg,
securities::SecurityDB &sec_db) :
securities::SecurityDB &sec_db,
NativeOrderFactory &factory) :
state(State::REPLAY),
latest_timestamp(to<OrderTimeStamp> (datetime::FIX_timestamp(datetime::now()))),
order_map(),
sec_db(sec_db),
free_buffers(),
jf_cfg(jf_cfg)
jf_cfg(jf_cfg),
order_factory(factory)
{}
State state;
@@ -53,21 +55,23 @@ struct NativeOrderMan::PImpl
OrderMap order_map;
securities::SecurityDB &sec_db;
std::vector<jetfix::OutFIXPtr> free_buffers;
config::JetFIX::Connection jf_cfg;
config::JetFIX::Connection jf_cfg;
NativeOrderFactory &order_factory;
};
NativeOrderMan::NativeOrderMan (config::JetFIX::Connection const&gw_connection,
securities::SecurityDB &sec_db,
NativeOrderFactory &order_factory,
std::vector<api::orderman::OrderState> const &existing_orders)
: me (new PImpl(gw_connection,sec_db))
: me (new PImpl(gw_connection,sec_db,order_factory))
{
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,os);
if (sec)
me->order_map[OrderKey(os.order_key())] = &(me->order_factory.make_order(*sec,os));
else {
LOG(OrderMan,Error,
"Cannot resolve security key {} in stored order {}. This is a serious problem. "
@@ -111,7 +115,7 @@ void NativeOrderMan::on(event::CreateNativeOrder const&create)
return;
}
order_ptr.reset(&order);
order_ptr = &order;
switch (me->state) {
case State::REPLAY:
@@ -124,7 +128,7 @@ void NativeOrderMan::on(event::CreateNativeOrder const&create)
native_order_state_change_signal(event::NativeOrderStateChange {&order,&order.header(),order.state()});
auto buffer = get_fix_bufer();
order.encode_create(me->latest_timestamp,create.price,create.quantity,&buffer->fix[0]);
out_gateway_msg_signal(event::OutGatewayMsg {buffer});
gateway_msg_signal(event::OutGatewayMsg {buffer});
break;
}
}
@@ -149,7 +153,7 @@ void NativeOrderMan::on(event::UpdateNativeOrder const&update)
if (order.can_be_udpated()) {
auto buffer = get_fix_bufer();
order.encode_update(me->latest_timestamp,update.price,update.quantity,&buffer->fix[0]);
out_gateway_msg_signal(event::OutGatewayMsg {buffer});
gateway_msg_signal(event::OutGatewayMsg {buffer});
}
else {
LOG(OrderMan,Warn, "Attempt to update in flight order {}. Request will be ignored",order.key().value());
@@ -181,7 +185,7 @@ void NativeOrderMan::on(event::CancelNativeOrder const&cancel)
if (order.can_be_canceled()) {
auto buffer = get_fix_bufer();
order.encode_cancel(me->latest_timestamp,&buffer->fix[0]);
out_gateway_msg_signal(event::OutGatewayMsg {buffer});
gateway_msg_signal(event::OutGatewayMsg {buffer});
}
else {
LOG(OrderMan,Warn, "Attempt to cancel in flight order {}. Request will be ignored",order.key().value());
@@ -275,10 +279,10 @@ void NativeOrderMan::on(event::ExecutionReport const&er)
native.set_order_quantity(er.data->order_quantity.value());
native.set_avg_price(er.data->avg_price.value());
native.set_filled_quantity(er.data->filled_quantity.value());
order_ptr = std::make_unique<NativeOrder>(*er.data->security,recovered);
order_ptr = &(me->order_factory.make_order(*er.data->security,recovered));
}
native_order_state_change_signal(
event::NativeOrderStateChange {order_ptr.get(), &order_ptr->header(),order_ptr->state()});
event::NativeOrderStateChange {order_ptr, &order_ptr->header(),order_ptr->state()});
}
void NativeOrderMan::on(event::CancelReject const&cr)
@@ -291,7 +295,7 @@ void NativeOrderMan::on(event::CancelReject const&cr)
if (order_ptr) {
order_ptr->set_reject_msg(cr.reject_msg);
native_order_state_change_signal(
event::NativeOrderStateChange {order_ptr.get(),&order_ptr->header(),order_ptr->state()});
event::NativeOrderStateChange {order_ptr,&order_ptr->header(),order_ptr->state()});
}
else
LOG(OrderMan,Error,
@@ -3,6 +3,7 @@
#include "server/sparkd/jetfix/common/OutFIXPtr.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/config/protos/jetfix.pb.h"
#include "server/sparkd/event_grid/event_grid_utils.h"
#include <memory>
#include <vector>
@@ -13,6 +14,7 @@ namespace securities {class SecurityDB;}
namespace api {namespace orderman {class OrderState;}}
namespace orderman {
class NativeOrderFactory;
namespace event {
class NativeOrderStateChange ;
@@ -33,6 +35,7 @@ class NativeOrderMan
public:
NativeOrderMan (config::JetFIX::Connection const&gw_connection,
securities::SecurityDB &sec_db,
NativeOrderFactory &order_factory,
std::vector<api::orderman::OrderState> const &existing_orders);
~NativeOrderMan();
@@ -49,8 +52,8 @@ public:
void on(event::TimeChange const&);
// out
std::function<void(event::NativeOrderStateChange const&)> native_order_state_change_signal;
std::function<void(event::OutGatewayMsg const&)> out_gateway_msg_signal;
event_grid::Signal<event::NativeOrderStateChange> native_order_state_change_signal;
event_grid::Signal<event::OutGatewayMsg> gateway_msg_signal;
private:
enum class State;
@@ -6,6 +6,7 @@
#include "server/sparkd/orderman/persistence/OrderDB.h"
#include "server/sparkd/orderman/events/NativeOrderStateChange.h"
#include "server/sparkd/orderman/events/OrderStateChange.h"
#include "server/sparkd/orderman/events/SpreaderOrderStateChange.h"
namespace bts {
namespace orderman {
@@ -30,7 +31,17 @@ OrderRecorder::~OrderRecorder () {}
void OrderRecorder::on(event::NativeOrderStateChange const&ch)
{
auto pb = event::to_pb(*ch.header,ch.current_state);
LOG(OrderMan,Info,"Storing order: {} ",utils::pb::to_string(pb));
LOG(OrderMan,Info,"Storing native order: {} ",utils::pb::to_string(pb));
me->store.store(pb);
std::vector<api::orderman::OrderState> v {pb};
order_state_change_signal(event::OrderStateChange {v});
}
void OrderRecorder::on(event::SpreaderOrderStateChange const&sc)
{
auto pb = event::to_pb(*sc.header,sc.current_state);
LOG(OrderMan,Info,"Storing spreader order: {} ",utils::pb::to_string(pb));
me->store.store(pb);
std::vector<api::orderman::OrderState> v {pb};
@@ -1,6 +1,7 @@
#pragma once
#include <memory>
#include "server/sparkd/event_grid/event_grid_utils.h"
namespace bts {
namespace event_grid {namespace event {class Init;}}
@@ -8,7 +9,11 @@ namespace orderman {
class OrderDB;
namespace event { class NativeOrderStateChange; class OrderStateChange; }
namespace event {
class NativeOrderStateChange;
class OrderStateChange;
class SpreaderOrderStateChange;
}
class OrderRecorder
{
@@ -19,9 +24,10 @@ public:
// in
void on(event_grid::event::Init const&);
void on(event::NativeOrderStateChange const&);
void on(event::SpreaderOrderStateChange const&);
// out
std::function<void(event::OrderStateChange const&)> order_state_change_signal;
event_grid::Signal<event::OrderStateChange> order_state_change_signal;
private:
struct PImpl;
@@ -20,22 +20,33 @@ using SpreaderOrderPtr = std::unique_ptr<SpreaderOrder>;
using SpreaderOrderMap = boost::container::flat_map<OrderKey, SpreaderOrderPtr>;
struct SpreaderOrderMan::PImpl {
PImpl(securities::SecurityDB &db) : sec_db(db), spreader_orders(),gateway_ready(false) {}
PImpl(securities::SecurityDB &db,
NativeOrderFactory &factory) :
sec_db(db),
native_order_factory(factory),
spreader_orders(),
gateway_ready(false)
{}
securities::SecurityDB &sec_db;
NativeOrderFactory &native_order_factory;
SpreaderOrderMap spreader_orders;
bool gateway_ready;
};
SpreaderOrderMan::SpreaderOrderMan (securities::SecurityDB &sec_db,
NativeOrderFactory &native_order_factory,
std::vector<api::orderman::OrderState> const &existing_orders)
: me(new PImpl(sec_db))
: me(new PImpl(sec_db,native_order_factory))
{
for (auto const &os : existing_orders)
if (os.has_spreader())
me->spreader_orders[OrderKey(os.order_key()) ] = std::make_unique<SpreaderOrder>(sec_db,os);
me->spreader_orders[OrderKey(os.order_key()) ] =
std::make_unique<SpreaderOrder>(sec_db,me->native_order_factory,os);
}
SpreaderOrderMan::~SpreaderOrderMan() {}
void SpreaderOrderMan::on(event_grid::event::Init const&)
{
LOG(OrderMan,Diag, "SpreaderOrderMan init");
@@ -51,7 +62,9 @@ void SpreaderOrderMan::on(event::CreateSpreaderOrder const&cso)
auto & order = me->spreader_orders[cso.order_key];
bts_assert(!order);
order = std::make_unique<SpreaderOrder> (me->sec_db,cso.order_key,cso.create);
order = std::make_unique<SpreaderOrder> (me->sec_db,
me->native_order_factory,
cso.order_key,cso.create);
order->init();
if (me->gateway_ready)
order->on_connect();
@@ -6,6 +6,7 @@
#include "server/sparkd/orderman/events/BookUpdate.h"
#include "server/sparkd/orderman/utils/orderman_utils.h"
#include "lib/api/services/OrderService.pb.h"
#include "server/sparkd/event_grid/event_grid_utils.h"
namespace bts {
namespace event_grid {namespace event {class Init;}}
@@ -24,14 +25,18 @@ class UpdateNativeOrder;
class CancelNativeOrder;
class MDSubscription;
}
class SpreaderOrder;
class NativeOrderFactory;
class SpreaderOrderMan
{
public:
SpreaderOrderMan (securities::SecurityDB &sec_db,
NativeOrderFactory &native_order_factory,
std::vector<api::orderman::OrderState> const &existing_orders);
~SpreaderOrderMan();
// in
void on(event_grid::event::Init const&);
void on(event::CreateSpreaderOrder const&);
@@ -43,13 +48,12 @@ public:
void on(event::NativeOrderStateChange const&);
// out
std::function<void(event::SpreaderOrderStateChange const&)> spreader_order_state_change_signal;
std::function<void(event::CreateNativeOrder const&)> create_native_order_signal;
std::function<void(event::UpdateNativeOrder const&)> update_native_order_signal;
std::function<void(event::CancelNativeOrder const&)> cancel_native_order_signal;
std::function<void(event::MDSubscription const&)> md_subscription_signal;
event_grid::Signal<event::SpreaderOrderStateChange> spreader_order_state_change_signal;
event_grid::Signal<event::CreateNativeOrder> create_native_order_signal;
event_grid::Signal<event::UpdateNativeOrder> update_native_order_signal;
event_grid::Signal<event::CancelNativeOrder> cancel_native_order_signal;
event_grid::Signal<event::MDSubscription> md_subscription_signal;
~SpreaderOrderMan();
private:
struct PImpl;
std::unique_ptr<PImpl> me;
@@ -2,6 +2,7 @@
#include "server/sparkd/orderman/events/TimeChange.h"
#include "server/sparkd/orderman/utils/orderman_utils.h"
#include "server/sparkd/event_grid/event_grid_utils.h"
#include "lib/utils/bts_chrono.h"
@@ -15,7 +16,7 @@ public:
TimeSource() : time_change_signal([](auto){}),_last() {}
// out
std::function<void(event::TimeChange const&)> time_change_signal;
event_grid::Signal<event::TimeChange> time_change_signal;
void do_work() {
auto now = Timer::now();
@@ -51,7 +51,6 @@ api::orderman::OrderState to_pb(NativeOrderHeader const&header,NativeOrderState
native.set_order_quantity(current_state.order_quantity.value());
native.set_filled_quantity(current_state.filled_quantity.value());
return result;
}
@@ -0,0 +1,40 @@
#include "server/sparkd/orderman/events/SpreaderOrderStateChange.h"
#include "server/sparkd/orderman/persistence/gen_order_id.h"
#include <sys/time.h>
namespace bts {
namespace orderman {
namespace event {
api::orderman::OrderState to_pb(SpreaderOrderHeader const&header,SpreaderOrderState const&current_state)
{
api::orderman::OrderState result;
result.set_order_key(header.order_key.value());
result.set_parent_order_key(null_order_key().value());
result.set_cti_code(header.cti_code);
result.set_customer_or_firm(header.customer_or_firm);
result.set_order_status(current_state.order_status);
auto &ts = *result.mutable_timestamp();
struct timeval tv;
gettimeofday(&tv, NULL);
ts.set_seconds(tv.tv_sec);
ts.set_nanos(tv.tv_usec * 1000);
auto &spreader = *result.mutable_spreader();
spreader.set_account_name(to_str(header.account_name));
spreader.set_operator_id(to_str(header.operator_id));
if (current_state.reject_msg)
result.set_reject_msg(*current_state.reject_msg);
spreader.set_target_price(current_state.target_price.value());
spreader.set_target_quantity(current_state.target_quantity.value());
return result;
}
}}}
@@ -2,6 +2,9 @@
#include <memory>
#include "lib/api/services/OrderService.pb.h"
#include "server/sparkd/orderman/utils/orderman_utils.h"
#include "server/sparkd/orderman/spreader_orders/SpreaderOrderHeader.h"
#include "server/sparkd/orderman/spreader_orders/SpreaderOrderState.h"
namespace bts {
namespace orderman {
@@ -10,9 +13,10 @@ namespace event {
class SpreaderOrderStateChange
{
public:
OrderKey order_key;
api::orderman::OrderStatus status;
std::string reject_msg;
SpreaderOrderHeader *header;
SpreaderOrderState current_state;
};
api::orderman::OrderState to_pb(SpreaderOrderHeader const&,SpreaderOrderState const&);
}}}
@@ -22,9 +22,12 @@ class NativeOrderMan;
class NativeOrder
{
public:
NativeOrder(api::Security const&sec,
api::orderman::OrderState const&os) :
protected:
// orders can only be built by special factory classes
friend class NativeOrderFactory;
friend class NativeOrderBuilder;
NativeOrder(api::Security const&sec, api::orderman::OrderState const&os) :
_fix_data(),
_state(),
_header(),
@@ -82,6 +85,7 @@ public:
_state.exchange_order_id = nullptr;
}
public:
void mark_rejected_by_spark(std::string const&msg)
{
_state.order_status = api::orderman::OS_REJECTED_BY_SPARK;
@@ -1,30 +1,92 @@
// #include "NativeOrderBuilder.h"
#include "NativeOrderBuilder.h"
#include "server/sparkd/orderman/native_orders/NativeOrderHeader.h"
#include "server/sparkd/orderman/native_orders/NativeOrder.h"
#include <mutex>
// namespace bts {
// namespace orderman {
namespace bts {
namespace orderman {
// struct NativeOrderBuilder::PImpl
// {
// PImpl(KeyGenerator const&kg,
// NativeOrderHeader const&header)
// : order_template(header),
// free(),
// in_use()
// {}
const auto order_batch_sz = 100;
// NativeOrderHeader order_template;
// std::vector<NativeOrderPtr> free;
// std::vector<NativeOrderPtr> in_use;
// KeyGenerator gen_keys;
// };
struct NativeOrderBuilder::PImpl
{
PImpl(KeyGenerator const&kg,
NativeOrderHeader const&header)
: order_template(header),
free(),
in_use(),
gen_keys(kg),
lock()
{}
// NativeOrderBuilder::NativeOrderBuilder(KeyGenerator const &kg,
// NativeOrderHeader const&header)
// : me (new PImpl(kg,header))
// {
// }
const NativeOrderHeader order_template;
std::vector<NativeOrderPtr> free;
std::vector<NativeOrderPtr> in_use;
// NativeOrderBuilder::~NativeOrderBuilder ()
// {}
KeyGenerator gen_keys;
std::mutex lock;
};
// }}
NativeOrderBuilder::NativeOrderBuilder(KeyGenerator const &kg,
NativeOrderHeader const&header)
: me (new PImpl(kg,header))
{}
NativeOrderBuilder::~NativeOrderBuilder () {}
NativeOrderHeader const&NativeOrderBuilder::order_header() const
{return me->order_template;}
NativeOrder& NativeOrderBuilder::operator()()
{
{
std::lock_guard<std::mutex> l(me->lock);
if(me->free.size()) {
auto result = std::move(me->free.back());
me->free.pop_back();
me->in_use.push_back(std::move(result));
return *(me->in_use.back());
}
}
refill();
return operator()();
}
void NativeOrderBuilder::refill()
{
int64_t to_add;
{
std::lock_guard<std::mutex> l(me->lock);
to_add = order_batch_sz - me->free.size();
}
if (to_add > 0) {
std::vector<OrderKey> keys;
keys.resize(to_add);
me->gen_keys(&keys);
std::vector<NativeOrderPtr> new_orders;
new_orders.resize(to_add);
NativeOrderHeader template_cpy = me->order_template;
for (int i = 0; i < to_add;i++) {
template_cpy.order_key = keys[i];
new_orders[i].reset(new NativeOrder(template_cpy));
}
{
std::lock_guard<std::mutex> l(me->lock);
for (int i = 0; i < to_add;i++)
me->free.push_back(std::move(new_orders[i]));
}
}
}
void NativeOrderBuilder::do_work()
{refill();}
}}
@@ -1,20 +1,28 @@
#pragma once
#include <memory>
#include <functional>
#include <vector>
#include "server/sparkd/orderman/utils/orderman_utils.h"
namespace bts {
namespace orderman {
class NativeOrder;
class NativeOrderHeader;
class NativeOrderBuilder
{
public:
using KeyGenerator = std::function<OrderKey(int)> ;
using KeyGenerator = std::function<void(std::vector<OrderKey> *)> ;
NativeOrderBuilder(KeyGenerator const&,NativeOrderHeader const&);
NativeOrderHeader const&order_header() const;
~NativeOrderBuilder();
void do_work();
NativeOrder& operator()();
private: struct PImpl;
void refill();
std::unique_ptr<PImpl> me;
};
@@ -0,0 +1,129 @@
#include "NativeOrderFactory.h"
#include "server/sparkd/orderman/native_orders/NativeOrderBuilder.h"
#include "server/sparkd/orderman/native_orders/NativeOrderHeader.h"
#include "server/sparkd/orderman/native_orders/NativeOrderBuilder.h"
#include "server/sparkd/orderman/persistence/gen_order_id.h"
#include "server/sparkd/orderman/native_orders/NativeOrder.h"
#include <mutex>
#include <algorithm>
namespace bts {
namespace orderman {
auto const key_batch_size = 1000;
struct NativeOrderFactory::PImpl
{
PImpl() : builders(), lock(),
free_order_ids(),
own_orders()
{}
std::vector<std::unique_ptr<NativeOrderBuilder>> builders;
std::mutex lock;
std::vector<OrderKey> free_order_ids;
std::vector<NativeOrderPtr> own_orders;
};
NativeOrderFactory::NativeOrderFactory () : me (new PImpl()) {}
NativeOrderFactory::~NativeOrderFactory () {}
NativeOrder& NativeOrderFactory::make_order(api::Security const&sec, api::orderman::OrderState const&os)
{
// create order
std::unique_ptr<NativeOrder> order (new NativeOrder (sec,os));
auto &result = *order;
// stash order
{
std::lock_guard<std::mutex> l(me->lock);
me->own_orders.push_back(std::move(order));
}
return result;
}
NativeOrder& NativeOrderFactory::make_order(NativeOrderHeader const&for_header)
{
// fill in key
auto header_copy = for_header;
std::vector<OrderKey> k;
k.resize(1);
generate_keys(&k);
header_copy.order_key = k[0];
// create order
std::unique_ptr<NativeOrder> order (new NativeOrder (header_copy));
auto &result = *order;
// stash order
{
std::lock_guard<std::mutex> l(me->lock);
me->own_orders.push_back(std::move(order));
}
return result;
}
NativeOrderBuilder& NativeOrderFactory::make_order_builder(NativeOrderHeader const&for_header)
{
std::lock_guard<std::mutex> l(me->lock);
auto it = std::find_if(me->builders.begin(),me->builders.end(),
[&for_header] (auto const&b) {return b->order_header() == for_header;});
if (it != me->builders.end())
return *it->get();
else {
auto result = std::make_unique<NativeOrderBuilder> ([this] (auto v) {this->generate_keys(v);},
for_header);
me->builders.push_back(std::move(result));
return *me->builders.back();
}
}
void NativeOrderFactory::generate_keys(std::vector<OrderKey> *keys)
{
auto how_many = keys->size();
{
std::lock_guard<std::mutex> l(me->lock);
if (me->free_order_ids.size() > how_many) {
auto start = me->free_order_ids.begin() + (me->free_order_ids.size()-how_many);
std::copy(start,me->free_order_ids.end(),keys->begin());
me->free_order_ids.resize(start - me->free_order_ids.begin());
return;
}
}
refill(how_many);
generate_keys(keys);
}
void NativeOrderFactory::refill(uint32_t at_least_these)
{
auto base = generate_order_keys(at_least_these);
{
std::lock_guard<std::mutex> l(me->lock);
for (uint32_t i = 0; i < at_least_these; i++)
me->free_order_ids.push_back(OrderKey(base.value()+i));
}
}
void NativeOrderFactory::do_work()
{
int64_t need_these = 0;
{
std::lock_guard<std::mutex> l(me->lock);
need_these = key_batch_size - me->free_order_ids.size();
}
if (need_these > 0)
refill(need_these);
}
}}
@@ -1,21 +1,32 @@
#pragma once
#include <memory>
#include <vector>
#include "server/sparkd/orderman/utils/orderman_utils.h"
namespace bts {
namespace api {namespace orderman {class OrderState;}}
namespace orderman {
class NativeOrderBuilder;
class NativeOrderHeader;
class NativeOrder;
class NativeOrderFactory
{
public:
NativeOrderFactory();
~NativeOrderFactory();
NativeOrderBuilder& get_builder(NativeOrderHeader const&for_header);
NativeOrder& make_order(api::Security const&sec, api::orderman::OrderState const&os);
NativeOrder& make_order(NativeOrderHeader const&for_header);
NativeOrderBuilder& make_order_builder(NativeOrderHeader const&for_header);
void do_work();
private:
struct PImpl;
void generate_keys(std::vector<OrderKey> *);
void refill(uint32_t at_least_these);
std::unique_ptr<PImpl> me;
};
@@ -26,4 +26,20 @@ public:
api::orderman::CTICode cti_code;
};
inline bool operator==(NativeOrderHeader const&lhs, NativeOrderHeader const&rhs) {
return
lhs.order_key == rhs.order_key &&
lhs.parent_order_key == rhs.parent_order_key &&
lhs.child_kind == rhs.child_kind &&
lhs.security == rhs.security &&
lhs.account_name == rhs.account_name &&
lhs.operator_id == rhs.operator_id &&
lhs.side == rhs.side &&
lhs.time_in_force == rhs.time_in_force &&
lhs.order_type == rhs.order_type &&
lhs.manual_order_indicator == rhs.manual_order_indicator &&
lhs.customer_or_firm == rhs.customer_or_firm &&
lhs.cti_code == rhs.cti_code ;
}
}}
@@ -14,7 +14,9 @@
#include "server/sparkd/orderman/components/OrderRecorder.h"
#include "server/sparkd/orderman/native_orders/NativeOrderHeader.h"
#include "server/sparkd/orderman/native_orders/NativeOrder.h"
#include "server/sparkd/orderman/native_orders/NativeOrderFactory.h"
#include "server/sparkd/orderman/persistence/gen_order_id.h"
#include "server/sparkd/orderman/components/SpreaderOrderMan.h"
#include "../events/BookUpdate.h"
#include "../events/CancelNativeOrder.h"
@@ -31,6 +33,10 @@
#include "../events/UpdateNativeOrder.h"
#include "../events/NativeFills.h"
#include "../events/OrderStateChange.h"
#include "../events/CreateSpreaderOrder.h"
#include "../events/UpdateSpreaderOrder.h"
#include "../events/CancelSpreaderOrder.h"
#include "../events/SpreaderOrderStateChange.h"
#include "lib/api/public/ServiceContext.h"
#include "server/sparkd/event_grid/events/Init.h"
@@ -64,7 +70,11 @@ using FastNode = event_grid::EventNode<event::BookUpdate,
event::NativeOrderStateChange,
event::OutGatewayMsg,
event::TimeChange ,
event::CreateSpreaderOrder,
event::UpdateSpreaderOrder,
event::CancelSpreaderOrder,
event::UpdateNativeOrder,
event::SpreaderOrderStateChange,
event_grid::event::Init> ;
using SlowNode = event_grid::EventNode<event::ExecutionReport,
@@ -72,28 +82,30 @@ using SlowNode = event_grid::EventNode<event::ExecutionReport,
event::NativeOrderStateChange,
event::NativeFills,
event::OrderStateChange,
event::SpreaderOrderStateChange,
event_grid::event::Init,
event::TimeChange>;
struct FastExecutor {
securities::SecurityDB &sec_db;
FastNode node;
Gateway gw;
MDSource md;
NativeOrderMan order_man;
SpreaderOrderMan spreader_man;
std::atomic<bool> done;
std::thread worker;
FastExecutor(config::JetFIX::Connection const& cfg,
securities::SecurityDB &db,
NativeOrderFactory &native_order_factory,
std::vector<api::orderman::OrderState> const &orders)
: sec_db(db),
node(),
: node(),
gw (cfg,db),
md(),
order_man(cfg,sec_db,orders),
order_man(cfg,db,native_order_factory, orders),
spreader_man(db,native_order_factory,orders),
done(false),
worker()
@@ -129,8 +141,26 @@ struct FastExecutor {
node.observe<event::TimeChange> ([this] (const auto &ev) {order_man.on(ev);});
// out
order_man.out_gateway_msg_signal = [this] (auto const &ev) {node.send<event::OutGatewayMsg>(ev);};
order_man.gateway_msg_signal = [this] (auto const &ev) {node.send<event::OutGatewayMsg>(ev);};
order_man.native_order_state_change_signal = [this] (auto const &ev) {node.send<event::NativeOrderStateChange>(ev);};
// wiring up spreader man
// in
node.observe<event_grid::event::Init> ([this] (const auto &ev) {spreader_man.on(ev);});
node.observe<event::CreateSpreaderOrder> ([this] (const auto &ev) {spreader_man.on(ev);});
node.observe<event::UpdateSpreaderOrder> ([this] (const auto &ev) {spreader_man.on(ev);});
node.observe<event::CancelSpreaderOrder> ([this] (const auto &ev) {spreader_man.on(ev);});
node.observe<event::BookUpdate> ([this] (const auto &ev) {spreader_man.on(ev);});
node.observe<event::GatewayStatusChange> ([this] (const auto &ev) {spreader_man.on(ev);});
node.observe<event::TimeChange> ([this] (const auto &ev) {spreader_man.on(ev);});
node.observe<event::NativeOrderStateChange> ([this] (const auto &ev) {spreader_man.on(ev);});
// out
spreader_man.spreader_order_state_change_signal = [this] (auto const &ev) {node.send<event::SpreaderOrderStateChange>(ev);};
spreader_man.create_native_order_signal = [this] (auto const &ev) {node.send<event::CreateNativeOrder>(ev);};
spreader_man.update_native_order_signal = [this] (auto const&ev) {node.send<event::UpdateNativeOrder>(ev);};
spreader_man.cancel_native_order_signal = [this] (auto const&ev) {node.send<event::CancelNativeOrder>(ev);};
spreader_man.md_subscription_signal = [this] (auto const&ev) {node.send<event::MDSubscription> (ev);};
}
~FastExecutor()
@@ -153,6 +183,7 @@ struct FastExecutor {
struct SlowExecutor {
securities::SecurityDB &sec_db;
NativeOrderFactory &native_order_factory;
OrderDB &order_db;
FillDB &fill_db;
SlowNode node;
@@ -164,8 +195,12 @@ struct SlowExecutor {
std::atomic<bool> done;
std::thread worker;
SlowExecutor(securities::SecurityDB &db,OrderDB &order_db,FillDB &fill_db)
SlowExecutor(securities::SecurityDB &db,
NativeOrderFactory &native_order_factory,
OrderDB &order_db,
FillDB &fill_db)
: sec_db(db),
native_order_factory(native_order_factory),
order_db(order_db),
fill_db(fill_db),
node(),
@@ -184,6 +219,7 @@ struct SlowExecutor {
// order storage
node.observe<event::NativeOrderStateChange> ([this] (const auto &ev) {order_recorder.on(ev);});
node.observe<event::SpreaderOrderStateChange> ([this] (const auto &ev) {order_recorder.on(ev);});
node.observe<event_grid::event::Init> ([this] (const auto &ev) {order_recorder.on(ev);});
// order PB publication
@@ -204,6 +240,7 @@ struct SlowExecutor {
while (!done) {
sec_db.do_work();
time_source.do_work();
native_order_factory.do_work();
if (!node.do_work())
std::this_thread::sleep_for(10ms);
}
@@ -217,10 +254,11 @@ struct OrderServiceServer::PImpl
{
PImpl() :
sec_db(),
native_order_factory(),
order_db(),
fill_db(),
fast(get_connection(),sec_db,order_db.retrieve_all()),
slow(sec_db,order_db,fill_db),
fast(get_connection(),sec_db,native_order_factory,order_db.retrieve_all()),
slow(sec_db,native_order_factory,order_db,fill_db),
state(State::PENDING_INIT),
known_native_orders(),
publish_orders(),
@@ -233,12 +271,13 @@ struct OrderServiceServer::PImpl
}
securities::SecurityDB sec_db;
NativeOrderFactory native_order_factory;
OrderDB order_db;
FillDB fill_db;
FastExecutor fast;
SlowExecutor slow;
State state;
std::map<OrderKey,NativeOrder*> known_native_orders;
OrderServiceServer::OrdersPublisher publish_orders;
std::set<uint32_t> known_orders;
@@ -268,7 +307,7 @@ OrderServiceServer::OrderServiceServer (bts::api::ServiceContext& ctx)
ctx.post([this,f] () {
this->on_fills(f);
});
});
});
me->slow.node.observe<event::OrderStateChange> ([&ctx,this] (auto const&os) {
ctx.post([this,os] () {
@@ -372,21 +411,6 @@ void OrderServiceServer::create_order(const api::orderman::CreateOrderRequest& r
api::orderman::CreateOrderResponse resp;
resp.set_order_key(0);
if (!req.has_native_order()) {
resp.set_order_key(0);
resp.set_error_code(api::orderman::OE_UNSUPPORTED_ORDER_TYPE);
on_reply(resp);
return;
}
auto const&native = req.native_order();
auto sec = me->sec_db.resolve(SecurityKey(native.security_key()));
if (!sec) {
resp.set_error_code(api::orderman::OE_UNKNOWN_SECURITY);
on_reply(resp);
return;
}
if (me->state == State::DISCONNECTED) {
resp.set_error_code(api::orderman::OE_GATEWAY_NOT_READY);
on_reply(resp);
@@ -399,32 +423,54 @@ void OrderServiceServer::create_order(const api::orderman::CreateOrderRequest& r
return;
}
auto header = NativeOrderHeader {
generate_order_keys(1),
null_order_key(),
api::orderman::COK_UNDEFINED,
sec,
to<AccountName>(native.account_name()),
to<OperatorID>(native.operator_id()),
native.side(),
native.time_in_force(),
native.order_type(),
native.manual_order_indicator(),
req.customer_or_firm(),
req.cti_code()
};
if (req.has_native()) {
auto ev = event::CreateNativeOrder {
Price(native.price()),
Quantity(native.quantity()),
new NativeOrder(header)
};
auto const&native = req.native();
auto sec = me->sec_db.resolve(SecurityKey(native.security_key()));
if (!sec) {
resp.set_error_code(api::orderman::OE_UNKNOWN_SECURITY);
on_reply(resp);
return;
}
auto header = NativeOrderHeader {
null_order_key(),
null_order_key(),
api::orderman::COK_UNDEFINED,
sec,
to<AccountName>(native.account_name()),
to<OperatorID>(native.operator_id()),
native.side(),
native.time_in_force(),
native.order_type(),
native.manual_order_indicator(),
req.customer_or_firm(),
req.cti_code()
};
auto ev = event::CreateNativeOrder {
Price(native.price()),
Quantity(native.quantity()),
&(me->native_order_factory.make_order(header))
};
me->fast.node.send<event::CreateNativeOrder>(ev);
me->fast.node.send<event::CreateNativeOrder>(ev);
resp.set_order_key(header.order_key.value());
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
resp.set_order_key(header.order_key.value());
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
}
else if (req.has_spreader()) {
auto ev = event::CreateSpreaderOrder {generate_order_keys(1),req};
me->fast.node.send<event::CreateSpreaderOrder> (ev);
resp.set_order_key(ev.order_key.value());
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
}
else {
resp.set_error_code(api::orderman::OE_UNSUPPORTED_ORDER_TYPE);
on_reply(resp);
}
}
void OrderServiceServer::cancel_order(const api::orderman::CancelOrderRequest& cancel,
@@ -445,18 +491,31 @@ void OrderServiceServer::cancel_order(const api::orderman::CancelOrderRequest& c
return;
}
auto it = me->native_order_objs.find(OrderKey(cancel.order_key()));
if (it == me->native_order_objs.end()) {
resp.set_error_code(api::orderman::OE_UNKNOWN_ORDER);
on_reply(resp);
return;
}
if (cancel.has_native()) {
auto it = me->native_order_objs.find(OrderKey(cancel.order_key()));
if (it == me->native_order_objs.end()) {
resp.set_error_code(api::orderman::OE_UNKNOWN_ORDER);
on_reply(resp);
return;
}
auto ev = event::CancelNativeOrder {it->second};
me->fast.node.send<event::CancelNativeOrder>(ev);
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
auto ev = event::CancelNativeOrder {it->second};
me->fast.node.send<event::CancelNativeOrder>(ev);
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
}
else if (cancel.has_spreader()) {
auto ev = event::CancelSpreaderOrder {OrderKey(cancel.order_key()),cancel.spreader()};
me->fast.node.send<event::CancelSpreaderOrder> (ev);
resp.set_order_key(ev.order_key.value());
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
}
else {
resp.set_order_key(cancel.order_key());
resp.set_error_code(api::orderman::OE_UNSUPPORTED_ORDER_TYPE);
on_reply(resp);
}
}
void OrderServiceServer::update_order(const api::orderman::UpdateOrderRequest& update,
@@ -465,13 +524,13 @@ void OrderServiceServer::update_order(const api::orderman::UpdateOrderRequest& u
api::orderman::UpdateOrderResponse resp;
resp.set_order_key(update.order_key());
if (!update.has_native_order()) {
if (!update.has_native()) {
resp.set_error_code(api::orderman::OE_UNSUPPORTED_ORDER_TYPE);
on_reply(resp);
return;
}
auto const&native = update.native_order();
auto const&native = update.native();
if (me->state == State::DISCONNECTED) {
resp.set_error_code(api::orderman::OE_GATEWAY_NOT_READY);
@@ -485,17 +544,31 @@ void OrderServiceServer::update_order(const api::orderman::UpdateOrderRequest& u
return;
}
auto it = me->native_order_objs.find(OrderKey(update.order_key()));
if (it == me->native_order_objs.end()) {
resp.set_error_code(api::orderman::OE_UNKNOWN_ORDER);
on_reply(resp);
return;
}
if (update.has_native()) {
auto it = me->native_order_objs.find(OrderKey(update.order_key()));
if (it == me->native_order_objs.end()) {
resp.set_error_code(api::orderman::OE_UNKNOWN_ORDER);
on_reply(resp);
return;
}
auto ev = event::UpdateNativeOrder {Price(native.price()),Quantity(native.quantity()),it->second};
me->fast.node.send<event::UpdateNativeOrder>(ev);
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
auto ev = event::UpdateNativeOrder {Price(native.price()),Quantity(native.quantity()),it->second};
me->fast.node.send<event::UpdateNativeOrder>(ev);
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
}
else if (update.has_spreader()) {
auto ev = event::UpdateSpreaderOrder {OrderKey(update.order_key()),update.spreader()};
me->fast.node.send<event::UpdateSpreaderOrder> (ev);
resp.set_order_key(ev.order_key.value());
resp.set_error_code(api::orderman::OE_OK);
on_reply(resp);
}
else {
resp.set_order_key(update.order_key());
resp.set_error_code(api::orderman::OE_UNSUPPORTED_ORDER_TYPE);
on_reply(resp);
}
}
}}
@@ -10,16 +10,18 @@ struct SpreaderOrder::PImpl
};
SpreaderOrder::SpreaderOrder(securities::SecurityDB &db,
NativeOrderFactory &f,
api::orderman::OrderState const&os)
: SpreaderOrderBase(db,os) , me (new PImpl())
: SpreaderOrderBase(db,f,os) , me (new PImpl())
{}
SpreaderOrder::SpreaderOrder(securities::SecurityDB &db, OrderKey k,
SpreaderOrder::SpreaderOrder(securities::SecurityDB &db,
NativeOrderFactory &f,
OrderKey k,
api::orderman::CreateOrderRequest const&cor)
: SpreaderOrderBase(db,k,cor) , me (new PImpl())
: SpreaderOrderBase(db,f,k,cor) , me (new PImpl())
{}
SpreaderOrder::~SpreaderOrder ()
{}
SpreaderOrder::~SpreaderOrder () {}
}}
@@ -9,17 +9,22 @@ namespace bts {
namespace api {namespace orderman {class OrderState; class CreateSpreaderOrder;}}
namespace securities {class SecurityDB;}
namespace orderman {
class Book;
class NativeOrderFactory;
class SpreaderOrder : public SpreaderOrderBase
{
public:
// old order recovered from disk
SpreaderOrder(securities::SecurityDB &,
NativeOrderFactory &,
api::orderman::OrderState const&);
// new order created by user
SpreaderOrder(securities::SecurityDB &, OrderKey ,
SpreaderOrder(securities::SecurityDB &,
NativeOrderFactory &,
OrderKey ,
api::orderman::CreateOrderRequest const&);
~SpreaderOrder();
@@ -37,6 +42,7 @@ public:
Price ,
std::string const&){};
void on_external_error(std::string const&){};
private:
struct PImpl;
std::unique_ptr<PImpl> me;
@@ -0,0 +1,137 @@
#include "SpreaderOrderBase.h"
#include "server/sparkd/securities/SecurityDB.h"
#include "server/sparkd/orderman/native_orders/NativeOrderFactory.h"
#include "server/sparkd/orderman/persistence/gen_order_id.h"
#include "server/sparkd/orderman/utils/orderman_utils.h"
#include "server/sparkd/orderman/spreader_orders/SpreaderOrderHeader.h"
#include "server/sparkd/orderman/spreader_orders/SpreaderOrderState.h"
#include "server/sparkd/orderman/events/SpreaderOrderStateChange.h"
namespace bts {
namespace orderman {
struct SpreaderOrderBase::PImpl
{
PImpl(securities::SecurityDB &db,
NativeOrderFactory &factory)
:
sec_db(db),
native_order_factory(factory),
header (),
change_spreader_state (),
create_native_order(),
update_native_order(),
cancel_native_order(),
subscribe_to_md(),
my_reject_msg()
{}
securities::SecurityDB &sec_db;
NativeOrderFactory &native_order_factory;
SpreaderOrderHeader header;
event_grid::Signal<event::SpreaderOrderStateChange> change_spreader_state ;
event_grid::Signal<event::CreateNativeOrder> create_native_order;
event_grid::Signal<event::UpdateNativeOrder> update_native_order;
event_grid::Signal<event::CancelNativeOrder> cancel_native_order;
event_grid::Signal<event::MDSubscription> subscribe_to_md;
std::vector<std::unique_ptr<std::string>> my_reject_msg;
};
SpreaderOrderBase::SpreaderOrderBase(securities::SecurityDB &db,
NativeOrderFactory &f,
api::orderman::OrderState const&s)
: me (new PImpl(db,f))
{
auto &spreader_state = s.spreader();
me->header = SpreaderOrderHeader {
OrderKey(s.order_key()),
to<AccountName>(spreader_state.account_name()),
to<OperatorID>(spreader_state.operator_id()),
s.customer_or_firm(),
s.cti_code()
};
}
SpreaderOrderBase::SpreaderOrderBase(securities::SecurityDB &db,
NativeOrderFactory &f,
OrderKey k,
api::orderman::CreateOrderRequest const&cor)
: me (new PImpl(db,f))
{
auto &spreader_create = cor.spreader();
me->header = SpreaderOrderHeader {
k,
to<AccountName>(spreader_create.account_name()),
to<OperatorID>(spreader_create.operator_id()),
cor.customer_or_firm(),
cor.cti_code()
};
}
SpreaderOrderBase::~SpreaderOrderBase () {}
api::Security const* SpreaderOrderBase::resolve_security(SecurityKey key) const
{return me->sec_db.resolve(key);}
OrderKey SpreaderOrderBase::key() const
{return me->header.order_key;}
void SpreaderOrderBase::subscribe_to_md(api::Security const&for_sec)
{me->subscribe_to_md(event::MDSubscription{&for_sec});}
SpreaderOrderBase::ChildFactory SpreaderOrderBase::get_child_factory(const api::Security& sec,
api::BuySell bs,
api::orderman::ChildOrderKind ck)
{
auto header = NativeOrderHeader {
null_order_key(),
me->header.order_key,
ck,
&sec,
me->header.account_name,
me->header.operator_id,
bs,
api::orderman::TIF_DAY,
api::orderman::OT_LIMIT,
api::orderman::MOI_NO,
me->header.customer_or_firm,
me->header.cti_code
};
auto &builder = me->native_order_factory.make_order_builder(header);
return ChildFactory (builder,
me->create_native_order,
me->update_native_order,
me->cancel_native_order);
}
void SpreaderOrderBase::init_signals(event_grid::Signal<event::SpreaderOrderStateChange> const&sc,
event_grid::Signal<event::CreateNativeOrder> const&cn,
event_grid::Signal<event::UpdateNativeOrder> const &un,
event_grid::Signal<event::CancelNativeOrder> const &xn,
event_grid::Signal<event::MDSubscription> const&smd)
{
me->change_spreader_state = sc;
me->create_native_order = cn;
me->update_native_order = un;
me->cancel_native_order = xn;
me->subscribe_to_md = smd;
}
void SpreaderOrderBase::report_state_change(SpreaderOrderState const&sos)
{
if (sos.reject_msg == nullptr)
me->change_spreader_state (event::SpreaderOrderStateChange {&me->header,sos});
else {
me->my_reject_msg.push_back(std::make_unique<std::string> (*sos.reject_msg));
SpreaderOrderState sos_copy = sos;
sos_copy.reject_msg = me->my_reject_msg.back().get();
me->change_spreader_state (event::SpreaderOrderStateChange {&me->header,sos_copy});
}
}
}}
@@ -1,97 +1,161 @@
#pragma once
#include <memory>
#include "server/sparkd/orderman/events/MDSubscription.h"
#include "lib/api/services/OrderService.pb.h"
#include "server/sparkd/orderman/events/CreateNativeOrder.h"
#include "server/sparkd/orderman/events/UpdateNativeOrder.h"
#include "lib/api/services/OrderService.pb.h"
#include "lib/domain_model/common.h"
#include "server/sparkd/event_grid/event_grid_utils.h"
#include "server/sparkd/orderman/events/CancelNativeOrder.h"
#include "server/sparkd/orderman/events/CreateNativeOrder.h"
#include "server/sparkd/orderman/events/MDSubscription.h"
#include "server/sparkd/orderman/events/UpdateNativeOrder.h"
#include "server/sparkd/orderman/native_orders/NativeOrder.h"
#include "server/sparkd/orderman/native_orders/NativeOrderBuilder.h"
namespace bts {
namespace api {class Security;}
namespace securities {class SecurityDB;}
namespace orderman {
namespace event {
class SpreaderOrderStateChange;
class CreateNativeOrder;
}
class SpreaderOrderMan;
class NativeOrderFactory;
class NativeOrderBuilder;
class SpreaderOrderState;
class SpreaderOrderBase
{
public:
// old order recovered from disk
SpreaderOrderBase(securities::SecurityDB &,
api::orderman::OrderState const&)
{}
// new order created by user
SpreaderOrderBase(securities::SecurityDB &, OrderKey ,
api::orderman::CreateOrderRequest const&)
{}
NativeOrderFactory &,
api::orderman::OrderState const&);
SpreaderOrderBase(securities::SecurityDB &,
NativeOrderFactory &,
OrderKey ,
api::orderman::CreateOrderRequest const&);
~SpreaderOrderBase();
api::Security const* resolve_security(SecurityKey key) const;
// class ChildOrder {
// public:
// void create (Price price, Quantity quantity) {
// _my_native_order.release();
// _create_native_order(event::CreateNativeOrder {price,quantity,_native_order});
// }
OrderKey key() const;
// void update (Price price, Quantity quantity) {
// bts_assert(_my_native_order.get() == nullptr);
// _update_native_order(event::UpdateNativeOrder {price,quantity,_native_order});
// }
void subscribe_to_md(api::Security const&for_sec);
void report_state_change(SpreaderOrderState const&);
class ChildOrder {
public:
ChildOrder (NativeOrder &my_order,
event_grid::Signal<event::CreateNativeOrder> const &c,
event_grid::Signal<event::UpdateNativeOrder> const &u,
event_grid::Signal<event::CancelNativeOrder> const &x) :
_order(&my_order),
_create(c),
_update(u),
_cancel(x)
{}
// void cancel() {
// bts_assert(_my_native_order.get() == nullptr);
// _cancel_native_order(event::CancelNativeOrder {_native_order});
// }
void create (Price price, Quantity quantity) {
_create(event::CreateNativeOrder {price,quantity,_order});
}
// private:
// ChildOrder (NativeOrder &my_order,
// std::function<void(event::CreateNativeOrder const&)> &c,
// std::function<void(event::UpdateNativeOrder const&)> &u,
// std::function<void(event::CancelNativeOrder const&)> &x) :
// _native_order(&my_order),
// _my_native_order(&my_order),
// _create_native_order(c),
// _update_native_order(u),
// _cancel_native_order(x)
// {}
void update (Price price, Quantity quantity) {
_update(event::UpdateNativeOrder {price,quantity,_order});
}
void cancel() {
_cancel(event::CancelNativeOrder {_order});
}
ChildOrder() :
_order(),
_create(),
_update(),
_cancel()
{}
// NativeOrder* _native_order;
// std::unique_ptr<NativeOrder> _my_native_order;
// std::function<void(event::CreateNativeOrder const&)> &_create_native_order;
// std::function<void(event::UpdateNativeOrder const&)> &_update_native_order;
// std::function<void(event::CancelNativeOrder const&)> &_cancel_native_order;
// };
ChildOrder(const ChildOrder&src) :
_order(),
_create(),
_update(),
_cancel()
{
operator=(src);
}
// class ChildOrderFactory {
// ChildOrder& operator() {
ChildOrder&operator=(const ChildOrder &rhs)
{
_order= rhs._order;
_create = rhs._create;
_update = rhs._update;
_cancel = rhs._cancel;
return *this;
}
// }
// private:
// std::vector<std::unique_ptr<ChildOrder>> _free;
// std::vector<std::unique_ptr<ChildOrder>> _used;
// std::shared_ptr<NativeOrderHeader> _order_template;
// };
// ChildOrderFactory get_child_order_factory(api::Security const&,
// api::orderman::ChildOrderKind,
// AccountName const&,
// OperatorID const&,
// api::BuySell);
private:
NativeOrder* _order;
event_grid::Signal<event::CreateNativeOrder> _create;
event_grid::Signal<event::UpdateNativeOrder> _update;
event_grid::Signal<event::CancelNativeOrder> _cancel;
};
class ChildFactory {
public:
ChildFactory(NativeOrderBuilder &builder,
event_grid::Signal<event::CreateNativeOrder> const &c,
event_grid::Signal<event::UpdateNativeOrder> const &u,
event_grid::Signal<event::CancelNativeOrder> const &x) :
_builder(&builder),
_create(c),
_update(u),
_cancel(x)
{}
ChildFactory(const ChildFactory &f):
_builder(f._builder),
_create(f._create),
_update(f._update),
_cancel(f._cancel)
{}
ChildFactory& operator=(ChildFactory const&f)
{
_builder = f._builder;
_create = f._create;
_update = f._update;
_cancel = f._cancel;
return *this;
}
ChildOrder operator()()
{
return ChildOrder ((*_builder)(), _create, _update, _cancel);
}
private:
NativeOrderBuilder *_builder;
event_grid::Signal<event::CreateNativeOrder> _create;
event_grid::Signal<event::UpdateNativeOrder> _update;
event_grid::Signal<event::CancelNativeOrder> _cancel;
};
ChildFactory get_child_factory(const api::Security&,api::BuySell,
api::orderman::ChildOrderKind);
// void subscribe_to_book(api::Security const&for_sec);
private:
friend class SpreaderOrderMan;
// std::function<void(event::SpreaderOrderStateChange const&)> spreader_order_state_change_signal;
// std::function<void(event::CreateNativeOrder const&)> create_native_order_signal;
// std::function<void(event::UpdateNativeOrder const&)> update_native_order_signal;
// std::function<void(event::CancelNativeOrder const&)> cancel_native_order_signal;
// std::function<void(event::MDSubscription const&)> md_subscription_signal;
void init_signals(event_grid::Signal<event::SpreaderOrderStateChange> const&,
event_grid::Signal<event::CreateNativeOrder> const&,
event_grid::Signal<event::UpdateNativeOrder> const&,
event_grid::Signal<event::CancelNativeOrder> const&,
event_grid::Signal<event::MDSubscription> const&);
struct PImpl;
std::unique_ptr<PImpl> me;
};
}}
@@ -0,0 +1,18 @@
#pragma once
#include <memory>
namespace bts {
namespace orderman {
class SpreaderOrderHeader
{
public:
OrderKey order_key;
AccountName account_name;
OperatorID operator_id;
api::orderman::CustomerOrFirm customer_or_firm;
api::orderman::CTICode cti_code;
};
}}
@@ -0,0 +1,17 @@
#pragma once
#include <memory>
namespace bts {
namespace orderman {
class SpreaderOrderState
{
public:
api::orderman::OrderStatus order_status;
Price target_price;
Quantity target_quantity;
std::string *reject_msg;
};
}}