diff --git a/src/lib/api/services/OrderService.proto b/src/lib/api/services/OrderService.proto index 46d39c780..742c9639e 100644 --- a/src/lib/api/services/OrderService.proto +++ b/src/lib/api/services/OrderService.proto @@ -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; } } diff --git a/src/server/sparkd/CMakeDeps.cmake b/src/server/sparkd/CMakeDeps.cmake index a39fe4da0..820eee3d6 100644 --- a/src/server/sparkd/CMakeDeps.cmake +++ b/src/server/sparkd/CMakeDeps.cmake @@ -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) \ No newline at end of file +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) \ No newline at end of file diff --git a/src/server/sparkd/cmds/TestOrderman.cpp b/src/server/sparkd/cmds/TestOrderman.cpp index 4cb354a37..8290d8826 100644 --- a/src/server/sparkd/cmds/TestOrderman.cpp +++ b/src/server/sparkd/cmds/TestOrderman.cpp @@ -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; } diff --git a/src/server/sparkd/event_grid/event_grid_utils.h b/src/server/sparkd/event_grid/event_grid_utils.h new file mode 100644 index 000000000..1ec2e89ff --- /dev/null +++ b/src/server/sparkd/event_grid/event_grid_utils.h @@ -0,0 +1,11 @@ +#pragma once + +#include + +namespace bts { +namespace event_grid { + +template +using Signal = std::function; + +}} diff --git a/src/server/sparkd/orderman/components/FillRecorder.h b/src/server/sparkd/orderman/components/FillRecorder.h index 2fb1da05e..a8552fe4c 100644 --- a/src/server/sparkd/orderman/components/FillRecorder.h +++ b/src/server/sparkd/orderman/components/FillRecorder.h @@ -1,6 +1,7 @@ #pragma once #include +#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 native_fill_signal; + event_grid::Signal native_fill_signal; private: struct PImpl; diff --git a/src/server/sparkd/orderman/components/Gateway.h b/src/server/sparkd/orderman/components/Gateway.h index 45986ae82..222067d74 100644 --- a/src/server/sparkd/orderman/components/Gateway.h +++ b/src/server/sparkd/orderman/components/Gateway.h @@ -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 @@ -32,12 +34,11 @@ public: void on(event::OutGatewayMsg const&m) {_gw.send(m.msg);} // out - std::function execution_report_signal; - std::function cancel_reject_signal; - std::function gateway_status_change_signal; - std::function gateway_begin_replay_signal; - std::function gateway_end_replay_signal; - + event_grid::Signal execution_report_signal; + event_grid::Signal cancel_reject_signal; + event_grid::Signal gateway_status_change_signal; + event_grid::Signal gateway_begin_replay_signal; + event_grid::Signal gateway_end_replay_signal; private: using FIXGw = jetfix::JetFIXGatewayid(); + 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 book_update_signal; + event_grid::Signal book_update_signal; MDSource() : book_update_signal([](auto){}), _handles(),_md_consumer(),_keep_alive() {} @@ -51,7 +55,6 @@ private: md2::MDConsumerHandle* handle; }; - std::vector _handles; md::MDRecoverableConsumer _md_consumer; std::vector> _keep_alive; diff --git a/src/server/sparkd/orderman/components/NativeOrderMan.cpp b/src/server/sparkd/orderman/components/NativeOrderMan.cpp index 91e3eb521..8bfb97fc0 100644 --- a/src/server/sparkd/orderman/components/NativeOrderMan.cpp +++ b/src/server/sparkd/orderman/components/NativeOrderMan.cpp @@ -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; +using OrderMap = boost::container::flat_map; 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 (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 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 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 (*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 = ℴ 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(*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, diff --git a/src/server/sparkd/orderman/components/NativeOrderMan.h b/src/server/sparkd/orderman/components/NativeOrderMan.h index 436373d64..2e0f938d5 100644 --- a/src/server/sparkd/orderman/components/NativeOrderMan.h +++ b/src/server/sparkd/orderman/components/NativeOrderMan.h @@ -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 #include @@ -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 const &existing_orders); ~NativeOrderMan(); @@ -49,8 +52,8 @@ public: void on(event::TimeChange const&); // out - std::function native_order_state_change_signal; - std::function out_gateway_msg_signal; + event_grid::Signal native_order_state_change_signal; + event_grid::Signal gateway_msg_signal; private: enum class State; diff --git a/src/server/sparkd/orderman/components/OrderRecorder.cpp b/src/server/sparkd/orderman/components/OrderRecorder.cpp index 0413d536b..8d61809c5 100644 --- a/src/server/sparkd/orderman/components/OrderRecorder.cpp +++ b/src/server/sparkd/orderman/components/OrderRecorder.cpp @@ -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 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 v {pb}; diff --git a/src/server/sparkd/orderman/components/OrderRecorder.h b/src/server/sparkd/orderman/components/OrderRecorder.h index 6cef52cda..2fa376e5e 100644 --- a/src/server/sparkd/orderman/components/OrderRecorder.h +++ b/src/server/sparkd/orderman/components/OrderRecorder.h @@ -1,6 +1,7 @@ #pragma once #include +#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 order_state_change_signal; + event_grid::Signal order_state_change_signal; private: struct PImpl; diff --git a/src/server/sparkd/orderman/components/SpreaderOrderMan.cpp b/src/server/sparkd/orderman/components/SpreaderOrderMan.cpp index f321a9de2..71199d1bf 100644 --- a/src/server/sparkd/orderman/components/SpreaderOrderMan.cpp +++ b/src/server/sparkd/orderman/components/SpreaderOrderMan.cpp @@ -20,22 +20,33 @@ using SpreaderOrderPtr = std::unique_ptr; using SpreaderOrderMap = boost::container::flat_map; 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 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(sec_db,os); + me->spreader_orders[OrderKey(os.order_key()) ] = + std::make_unique(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 (me->sec_db,cso.order_key,cso.create); + order = std::make_unique (me->sec_db, + me->native_order_factory, + cso.order_key,cso.create); order->init(); if (me->gateway_ready) order->on_connect(); diff --git a/src/server/sparkd/orderman/components/SpreaderOrderMan.h b/src/server/sparkd/orderman/components/SpreaderOrderMan.h index f1a5f47ce..b8a7138b8 100644 --- a/src/server/sparkd/orderman/components/SpreaderOrderMan.h +++ b/src/server/sparkd/orderman/components/SpreaderOrderMan.h @@ -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 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 spreader_order_state_change_signal; - std::function create_native_order_signal; - std::function update_native_order_signal; - std::function cancel_native_order_signal; - std::function md_subscription_signal; + event_grid::Signal spreader_order_state_change_signal; + event_grid::Signal create_native_order_signal; + event_grid::Signal update_native_order_signal; + event_grid::Signal cancel_native_order_signal; + event_grid::Signal md_subscription_signal; - ~SpreaderOrderMan(); private: struct PImpl; std::unique_ptr me; diff --git a/src/server/sparkd/orderman/components/TimeSource.h b/src/server/sparkd/orderman/components/TimeSource.h index 316b5e4a2..95368e3a1 100644 --- a/src/server/sparkd/orderman/components/TimeSource.h +++ b/src/server/sparkd/orderman/components/TimeSource.h @@ -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 time_change_signal; + event_grid::Signal time_change_signal; void do_work() { auto now = Timer::now(); diff --git a/src/server/sparkd/orderman/events/NativeOrderStateChange.cpp b/src/server/sparkd/orderman/events/NativeOrderStateChange.cpp index 129759b34..fb0a3e5a2 100644 --- a/src/server/sparkd/orderman/events/NativeOrderStateChange.cpp +++ b/src/server/sparkd/orderman/events/NativeOrderStateChange.cpp @@ -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; } diff --git a/src/server/sparkd/orderman/events/SpreaderOrderStateChange.cpp b/src/server/sparkd/orderman/events/SpreaderOrderStateChange.cpp new file mode 100644 index 000000000..579223613 --- /dev/null +++ b/src/server/sparkd/orderman/events/SpreaderOrderStateChange.cpp @@ -0,0 +1,40 @@ +#include "server/sparkd/orderman/events/SpreaderOrderStateChange.h" +#include "server/sparkd/orderman/persistence/gen_order_id.h" + +#include + +namespace bts { +namespace orderman { +namespace event { + +api::orderman::OrderState to_pb(SpreaderOrderHeader const&header,SpreaderOrderState const¤t_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; +} + +}}} diff --git a/src/server/sparkd/orderman/events/SpreaderOrderStateChange.h b/src/server/sparkd/orderman/events/SpreaderOrderStateChange.h index cbaddf6fc..536f2dcbe 100644 --- a/src/server/sparkd/orderman/events/SpreaderOrderStateChange.h +++ b/src/server/sparkd/orderman/events/SpreaderOrderStateChange.h @@ -2,6 +2,9 @@ #include #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&); + }}} diff --git a/src/server/sparkd/orderman/native_orders/NativeOrder.h b/src/server/sparkd/orderman/native_orders/NativeOrder.h index f89d5f55f..344c59fe3 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrder.h +++ b/src/server/sparkd/orderman/native_orders/NativeOrder.h @@ -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; diff --git a/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp b/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp index cac59b68d..14578c156 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp +++ b/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp @@ -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 -// 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 free; -// std::vector 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 free; + std::vector 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 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 l(me->lock); + to_add = order_batch_sz - me->free.size(); + } + + if (to_add > 0) { + std::vector keys; + keys.resize(to_add); + me->gen_keys(&keys); + + std::vector 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 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();} + +}} diff --git a/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.h b/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.h index b861cb3ec..47a72ca15 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.h +++ b/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.h @@ -1,20 +1,28 @@ #pragma once #include +#include +#include +#include "server/sparkd/orderman/utils/orderman_utils.h" namespace bts { namespace orderman { +class NativeOrder; +class NativeOrderHeader; + class NativeOrderBuilder { public: - using KeyGenerator = std::function ; + using KeyGenerator = std::function *)> ; NativeOrderBuilder(KeyGenerator const&,NativeOrderHeader const&); + NativeOrderHeader const&order_header() const; ~NativeOrderBuilder(); void do_work(); NativeOrder& operator()(); private: struct PImpl; + void refill(); std::unique_ptr me; }; diff --git a/src/server/sparkd/orderman/native_orders/NativeOrderFactory.cpp b/src/server/sparkd/orderman/native_orders/NativeOrderFactory.cpp new file mode 100644 index 000000000..37ba3bc28 --- /dev/null +++ b/src/server/sparkd/orderman/native_orders/NativeOrderFactory.cpp @@ -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 +#include + +namespace bts { +namespace orderman { + +auto const key_batch_size = 1000; + +struct NativeOrderFactory::PImpl +{ + PImpl() : builders(), lock(), + free_order_ids(), + own_orders() + {} + + std::vector> builders; + std::mutex lock; + std::vector free_order_ids; + std::vector 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 order (new NativeOrder (sec,os)); + auto &result = *order; + + // stash order + { + std::lock_guard 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 k; + k.resize(1); + generate_keys(&k); + header_copy.order_key = k[0]; + + // create order + std::unique_ptr order (new NativeOrder (header_copy)); + auto &result = *order; + + // stash order + { + std::lock_guard 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 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 ([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 *keys) +{ + auto how_many = keys->size(); + + { + std::lock_guard 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 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 l(me->lock); + need_these = key_batch_size - me->free_order_ids.size(); + } + + if (need_these > 0) + refill(need_these); +} + + +}} diff --git a/src/server/sparkd/orderman/native_orders/NativeOrderFactory.h b/src/server/sparkd/orderman/native_orders/NativeOrderFactory.h index ae32ed949..805ed4af9 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrderFactory.h +++ b/src/server/sparkd/orderman/native_orders/NativeOrderFactory.h @@ -1,21 +1,32 @@ #pragma once #include +#include +#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 *); + void refill(uint32_t at_least_these); std::unique_ptr me; }; diff --git a/src/server/sparkd/orderman/native_orders/NativeOrderHeader.h b/src/server/sparkd/orderman/native_orders/NativeOrderHeader.h index 175bf0238..05702a4ad 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrderHeader.h +++ b/src/server/sparkd/orderman/native_orders/NativeOrderHeader.h @@ -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 ; +} + }} diff --git a/src/server/sparkd/orderman/service/OrderServiceServer.cpp b/src/server/sparkd/orderman/service/OrderServiceServer.cpp index 0f64788fc..489d306a6 100644 --- a/src/server/sparkd/orderman/service/OrderServiceServer.cpp +++ b/src/server/sparkd/orderman/service/OrderServiceServer.cpp @@ -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 ; using SlowNode = event_grid::EventNode; struct FastExecutor { - securities::SecurityDB &sec_db; FastNode node; Gateway gw; MDSource md; NativeOrderMan order_man; - + SpreaderOrderMan spreader_man; + std::atomic done; std::thread worker; FastExecutor(config::JetFIX::Connection const& cfg, securities::SecurityDB &db, + NativeOrderFactory &native_order_factory, std::vector 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 ([this] (const auto &ev) {order_man.on(ev);}); // out - order_man.out_gateway_msg_signal = [this] (auto const &ev) {node.send(ev);}; + order_man.gateway_msg_signal = [this] (auto const &ev) {node.send(ev);}; order_man.native_order_state_change_signal = [this] (auto const &ev) {node.send(ev);}; + + // wiring up spreader man + // in + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + node.observe ([this] (const auto &ev) {spreader_man.on(ev);}); + + // out + spreader_man.spreader_order_state_change_signal = [this] (auto const &ev) {node.send(ev);}; + spreader_man.create_native_order_signal = [this] (auto const &ev) {node.send(ev);}; + spreader_man.update_native_order_signal = [this] (auto const&ev) {node.send(ev);}; + spreader_man.cancel_native_order_signal = [this] (auto const&ev) {node.send(ev);}; + spreader_man.md_subscription_signal = [this] (auto const&ev) {node.send (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 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 ([this] (const auto &ev) {order_recorder.on(ev);}); + node.observe ([this] (const auto &ev) {order_recorder.on(ev);}); node.observe ([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 known_native_orders; OrderServiceServer::OrdersPublisher publish_orders; std::set known_orders; @@ -268,7 +307,7 @@ OrderServiceServer::OrderServiceServer (bts::api::ServiceContext& ctx) ctx.post([this,f] () { this->on_fills(f); }); - }); + }); me->slow.node.observe ([&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(native.account_name()), - to(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(native.account_name()), + to(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(ev); + me->fast.node.send(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 (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(ev); - resp.set_error_code(api::orderman::OE_OK); - on_reply(resp); + auto ev = event::CancelNativeOrder {it->second}; + me->fast.node.send(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 (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(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(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 (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); + } } }} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index e1fdee7bd..02507f367 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -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 () {} }} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index d7aa2e8e7..a93041097 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -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 me; diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp new file mode 100644 index 000000000..35a15e5ba --- /dev/null +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp @@ -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 change_spreader_state ; + event_grid::Signal create_native_order; + event_grid::Signal update_native_order; + event_grid::Signal cancel_native_order; + event_grid::Signal subscribe_to_md; + std::vector> 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(spreader_state.account_name()), + to(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(spreader_create.account_name()), + to(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 const&sc, + event_grid::Signal const&cn, + event_grid::Signal const &un, + event_grid::Signal const &xn, + event_grid::Signal 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 (*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}); + } +} + +}} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h index 8aa01cb4e..4474d6b3a 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h @@ -1,97 +1,161 @@ #pragma once #include -#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 const &c, + event_grid::Signal const &u, + event_grid::Signal 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 &c, - // std::function &u, - // std::function &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 _my_native_order; - // std::function &_create_native_order; - // std::function &_update_native_order; - // std::function &_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> _free; - // std::vector> _used; - // std::shared_ptr _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 _create; + event_grid::Signal _update; + event_grid::Signal _cancel; + }; + + + class ChildFactory { + public: + ChildFactory(NativeOrderBuilder &builder, + event_grid::Signal const &c, + event_grid::Signal const &u, + event_grid::Signal 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 _create; + event_grid::Signal _update; + event_grid::Signal _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 spreader_order_state_change_signal; - // std::function create_native_order_signal; - // std::function update_native_order_signal; - // std::function cancel_native_order_signal; - // std::function md_subscription_signal; + void init_signals(event_grid::Signal const&, + event_grid::Signal const&, + event_grid::Signal const&, + event_grid::Signal const&, + event_grid::Signal const&); + struct PImpl; + std::unique_ptr me; }; }} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderHeader.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderHeader.h new file mode 100644 index 000000000..0d1eb605c --- /dev/null +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderHeader.h @@ -0,0 +1,18 @@ +#pragma once + +#include + +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; +}; + +}} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderState.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderState.h new file mode 100644 index 000000000..fee915c93 --- /dev/null +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderState.h @@ -0,0 +1,17 @@ +#pragma once + +#include + +namespace bts { +namespace orderman { + +class SpreaderOrderState +{ +public: + api::orderman::OrderStatus order_status; + Price target_price; + Quantity target_quantity; + std::string *reject_msg; +}; + +}}