diff --git a/.clang-format b/.clang-format new file mode 100644 index 000000000..bc7c7089c --- /dev/null +++ b/.clang-format @@ -0,0 +1 @@ +IndentWidth: 3 diff --git a/src/server/sparkd/main.cpp b/src/server/sparkd/main.cpp index b95e75737..3ceee4fb6 100644 --- a/src/server/sparkd/main.cpp +++ b/src/server/sparkd/main.cpp @@ -15,23 +15,23 @@ #include "server/sparkd/cmds/TestOrderman.h" int main(int argc, char **argv) { - using namespace bts; + using namespace bts; - os::set_thread_name("main"); - utils::init_spark_lib(); - BEGIN_CMD; - REGISTER(Test); - REGISTER(Help); - REGISTER(Run); - REGISTER(Md); - REGISTER(TestOrderman); - REGISTER(TestCeloxica); - REGISTER(ConfigCheck); - REGISTER(RunSim); - REGISTER(Benchmark); - END_CMD; + os::set_thread_name("main"); + utils::init_spark_lib(); + BEGIN_CMD; + REGISTER(Test); + REGISTER(Help); + REGISTER(Run); + REGISTER(Md); + REGISTER(TestOrderman); + REGISTER(TestCeloxica); + REGISTER(ConfigCheck); + REGISTER(RunSim); + REGISTER(Benchmark); + END_CMD; - utils::finit_spark_lib(); - std::string s; - return 0; + utils::finit_spark_lib(); + std::string s; + return 0; } diff --git a/src/server/sparkd/orderman2/actors/order_manager/OrderManager.cpp b/src/server/sparkd/orderman2/actors/order_manager/OrderManager.cpp index d93601353..4ab58f035 100644 --- a/src/server/sparkd/orderman2/actors/order_manager/OrderManager.cpp +++ b/src/server/sparkd/orderman2/actors/order_manager/OrderManager.cpp @@ -2,15 +2,14 @@ #include "OrderManager.h" - -#include - #include "server/sparkd/jetfix/common/OutFIX.h" +#include "server/sparkd/orderman2/actors/order_manager/OrderServices.h" +#include "server/sparkd/orderman2/events/OrderManagerReadyEvent.h" #include "server/sparkd/orderman2/order_factory/OrderFactory.h" #include "server/sparkd/orderman2/orders/Order.h" #include "server/sparkd/securities/ISecurityDB.h" -#include "server/sparkd/orderman2/actors/order_manager/OrderServices.h" -#include "server/sparkd/orderman2/events/OrderManagerReadyEvent.h" + +#include namespace bts { namespace orderman2 { @@ -18,33 +17,27 @@ namespace orderman2 { using namespace mercury; const auto fix_buffer_pool_size = 10000; -enum class OrderManager::State {WAIT_SEC, WAIT_ORDERS, READY } ; +enum class OrderManager::State { WAIT_SEC, WAIT_ORDERS, READY }; struct OrderManager::OrderInfo { - OrderInfo (Order &o, OrderServicesData &data) - : order(&o), - order_services(std::make_unique (o,data)) - {} + OrderInfo(Order &o, OrderServicesData &data) + : order(&o), order_services(std::make_unique(o, data)) {} OrderInfo() = default; OrderInfo(OrderInfo &&src) = default; - OrderInfo& operator=(OrderInfo &&src) = default; + OrderInfo &operator=(OrderInfo &&src) = default; Order *order; std::unique_ptr order_services; }; -struct OrderManager::PImpl -{ - PImpl(config::JetFIX::Connection const &cfg, Actor&owner) : - state (State::WAIT_SEC), - cfg(cfg), - gw_name(GatewayName(cfg.name())), - services_data(cfg,owner) - {} +struct OrderManager::PImpl { + PImpl(config::JetFIX::Connection const &cfg, Actor &owner) + : state(State::WAIT_SEC), cfg(cfg), gw_name(GatewayName(cfg.name())), + services_data(cfg, owner) {} State state; - std::unordered_map orders; + std::unordered_map orders; mercury::Actor::SubHandle stored_order_sub; const config::JetFIX::Connection cfg; const GatewayName gw_name; @@ -52,48 +45,50 @@ struct OrderManager::PImpl mercury::Stream pub_ready; }; -OrderManager::OrderManager (config::JetFIX::Connection const&cfg) : me (new PImpl(cfg,*this)) {} -OrderManager::~OrderManager () {} +OrderManager::OrderManager(config::JetFIX::Connection const &cfg) + : me(new PImpl(cfg, *this)) {} +OrderManager::~OrderManager() {} -void OrderManager::init() -{ - subscribe([this] (auto const&sec_update) {this->on_securities(sec_update);}); +void OrderManager::init() { + subscribe( + [this](auto const &sec_update) { this->on_securities(sec_update); }); } -void OrderManager::on_securities(const mercury::Update &update) -{ +void OrderManager::on_securities( + const mercury::Update &update) { if (update.events) { - + // update our security db for (auto ev : *(update.events)) { auto sec_ptr = ev.security; - me->services_data.sec_db.securities[SecurityKey(sec_ptr->id())] = sec_ptr; + me->services_data.sec_db.securities[SecurityKey(sec_ptr->id())] = + sec_ptr; } if (me->state == State::WAIT_SEC) { // obtain recovered orders me->state = State::WAIT_ORDERS; - me->stored_order_sub = - subscribe (me->gw_name, - [this] (auto const&orders) - {this->on_order_recovery(orders);}); + me->stored_order_sub = subscribe( + me->gw_name, + [this](auto const &orders) { this->on_order_recovery(orders); }); } } } -void OrderManager::on_order_recovery(const mercury::Update &update) -{ - if (update.events) +void OrderManager::on_order_recovery( + const mercury::Update &update) { + if (update.events) if (me->state == State::WAIT_ORDERS) { // Got the first batch of persisted orders which has to match // the orders stored on disk (since we are the only ones // producing new orders) for (auto const &ev : *(update.events)) { - auto &order = me->services_data.order_factory.recover(*ev.order_record); - auto const&ostate = ev.order_record->state(); - OrderInfo oi {order,me->services_data}; + auto &order = + me->services_data.order_factory.recover(*ev.order_record); + auto const &ostate = ev.order_record->state(); + OrderInfo oi{order, me->services_data}; auto serv_ptr = oi.order_services.get(); - me->orders[order.key()] = std::move(oi); + me->orders[order.key()] = std::move(oi); order.on_activate(Price(ostate.price()), Quantity(ostate.quantity()), *serv_ptr); } @@ -115,34 +110,45 @@ void OrderManager::on_order_recovery(const mercury::Update &up // it. In that case we will do our best to recover the order // from the execution report. That is the only purpose of // this subscription. - subscribe (me->gw_name, - [this] (auto const&ev) {this->on_execution_report(ev);}); + subscribe( + me->gw_name, + [this](auto const &ev) { this->on_execution_report(ev); }); // we need to know the gateway status because some of our // orders need to know it at activation time. The // ContentSubscription mechanism does not provide a synopsis // so we cache the last known state of the gateway ourselves // and offer it to the orders. - subscribe (me->gw_name, - [this] (auto const&ev) {this->on_gateway_state(ev);}); + subscribe( + me->gw_name, + [this](auto const &ev) { this->on_gateway_state(ev); }); // Order creation and maintenance - subscribe(me->gw_name, [this] (auto const&ev) {this->on_activate_order(ev);}); - subscribe(me->gw_name, [this] (auto const&ev) {this->on_update_order(ev);}); - subscribe(me->gw_name, [this] (auto const&ev) {this->on_cancel_order(ev);}); - subscribe(me->gw_name, [this] (auto const&ev) {this->on_crack_order(ev);}); + subscribe(me->gw_name, [this](auto const &ev) { + this->on_activate_order(ev); + }); + subscribe(me->gw_name, [this](auto const &ev) { + this->on_update_order(ev); + }); + subscribe(me->gw_name, [this](auto const &ev) { + this->on_cancel_order(ev); + }); + subscribe( + me->gw_name, [this](auto const &ev) { this->on_crack_order(ev); }); // clock - subscribe([this] (auto const &ev) {this->on_timer(ev);}); - + subscribe( + [this](auto const &ev) { this->on_timer(ev); }); + // Allocating FIX buffers is relatively expensive so we try // to keep a pool of pre-allocated buffers ready. To // replinish the pool we issue CreateFIXBufferRequestEvent // and listen for replies while (free_buffers().size() != fix_buffer_pool_size) free_buffers().push_back(std::make_shared(me->cfg)); - subscribe(me->gw_name, - [this] (auto const &ev) {this->on_new_fix_buffer(ev);}); + subscribe( + me->gw_name, + [this](auto const &ev) { this->on_new_fix_buffer(ev); }); // Subscription setup/teardown is a relatively heavy // operation. For that reason we use coarse-grained topics to @@ -150,142 +156,161 @@ void OrderManager::on_order_recovery(const mercury::Update &up // can impose more fine-grained and light weight filtering on // top of those topic subscriptions through the // ContentSubscription helper class. - me->services_data.md_subs = ContentSubscription (*this); - me->services_data.child_order_subs = ContentSubscription (*this); - me->services_data.md_subs = ContentSubscription (*this); - me->services_data.exe_report_subs = ContentSubscription (*this,me->gw_name); - me->services_data.cancel_reject_subs = ContentSubscription (*this,me->gw_name); - me->services_data.gateway_status_subs = ContentSubscription (*this); - me->services_data.time_subs = ContentSubscription (*this); - me->services_data.order_creation_subs = ContentSubscription (*this,me->gw_name); + me->services_data.md_subs = + ContentSubscription(*this); + me->services_data.child_order_subs = + ContentSubscription(*this); + me->services_data.md_subs = + ContentSubscription(*this); + me->services_data.exe_report_subs = + ContentSubscription(*this, me->gw_name); + me->services_data.cancel_reject_subs = + ContentSubscription(*this, me->gw_name); + me->services_data.gateway_status_subs = + ContentSubscription(*this); + me->services_data.time_subs = + ContentSubscription(*this); + me->services_data.order_creation_subs = + ContentSubscription(*this, me->gw_name); - // Outputs - me->services_data.order_state_pub = make_stream(); - me->services_data.out_fix_pub = make_stream(me->gw_name); - me->services_data.activate_order_pub = make_stream(me->gw_name); - me->services_data.update_order_pub = make_stream(me->gw_name); - me->services_data.cancel_order_pub = make_stream(me->gw_name); - me->services_data.crack_order_pub = make_stream(me->gw_name); - me->services_data.create_order_req_pub = make_stream(me->gw_name); - me->services_data.create_fix_req_pub = make_stream(me->gw_name); + // Outputs + me->services_data.order_state_pub = + make_stream(); + me->services_data.out_fix_pub = + make_stream(me->gw_name); + me->services_data.activate_order_pub = + make_stream(me->gw_name); + me->services_data.update_order_pub = + make_stream(me->gw_name); + me->services_data.cancel_order_pub = + make_stream(me->gw_name); + me->services_data.crack_order_pub = + make_stream(me->gw_name); + me->services_data.create_order_req_pub = + make_stream(me->gw_name); + me->services_data.create_fix_req_pub = + make_stream(me->gw_name); me->services_data.md_request_pub = make_stream(); - me->services_data.report_order_state_pub = make_stream(); - me->pub_ready = make_stream (me->gw_name); + me->services_data.report_order_state_pub = + make_stream(); + me->pub_ready = make_stream(me->gw_name); // signal that we are ready publish(me->pub_ready); } } -void OrderManager::on_execution_report(const mercury::Update &m) -{ +void OrderManager::on_execution_report( + const mercury::Update &m) { if (m.events) - for (auto const &report: *m.events) { + for (auto const &report : *m.events) { auto k = report.data->order_key; auto it = me->orders.find(k); if (it == me->orders.end()) { - LOG(OrderMan,Error, - "Received an execution report for an unknown order with key {}. " - "Order state will be reconstructed from this report but some information " + LOG(OrderMan, Error, + "Received an execution report for an unknown order with key " + "{}. " + "Order state will be reconstructed from this report but some " + "information " "will be lost, including CustomerOrFirm,CTI code and " - "parent order id", k.value()); - auto order = &me->services_data.order_factory.recreate_from_exe_report(*report.data); - OrderInfo oi {*order,me->services_data}; + "parent order id", + k.value()); + auto order = + &me->services_data.order_factory.recreate_from_exe_report( + *report.data); + OrderInfo oi{*order, me->services_data}; auto serv_ptr = oi.order_services.get(); - me->orders[order->key()] = std::move(oi); - order->on_activate(report.data->price,report.data->quantity,*serv_ptr); + me->orders[order->key()] = std::move(oi); + order->on_activate(report.data->price, report.data->quantity, + *serv_ptr); } } -} +} -void OrderManager::on_activate_order(const mercury::Update &m) -{ +void OrderManager::on_activate_order( + const mercury::Update &m) { if (m.events) - for (auto const &ev: *m.events) { - auto order = ev.order; + for (auto const &ev : *m.events) { + auto order = ev.order; auto k = order->key(); bts_assert(me->orders.find(k) != me->orders.end()); - OrderInfo oi {*order,me->services_data}; + OrderInfo oi{*order, me->services_data}; auto serv_ptr = oi.order_services.get(); me->orders[k] = std::move(oi); - order->on_activate(ev.price,ev.quantity,*serv_ptr); + order->on_activate(ev.price, ev.quantity, *serv_ptr); } -} -void OrderManager::on_update_order(const mercury::Update &m) -{ +} +void OrderManager::on_update_order(const mercury::Update &m) { if (m.events) - for (auto const &ev: *m.events) { + for (auto const &ev : *m.events) { auto k = ev.key(); auto it = me->orders.find(k); - if (it != me->orders.end()) - it->second.order->on_update(ev.price,ev.quantity); + if (it != me->orders.end()) + it->second.order->on_update(ev.price, ev.quantity); else { - LOG(OrderMan,Error, + LOG(OrderMan, Error, "Received an update request for an unknown order {}. " "This should not happen and likely indicates a serious bug. ", ev.key().value()); } } -} +} -void OrderManager::on_cancel_order(const mercury::Update &m) -{ +void OrderManager::on_cancel_order(const mercury::Update &m) { if (m.events) - for (auto const &ev: *m.events) { + for (auto const &ev : *m.events) { auto k = ev.key(); auto it = me->orders.find(k); - if (it != me->orders.end()) + if (it != me->orders.end()) it->second.order->on_cancel(); else { - LOG(OrderMan,Error, + LOG(OrderMan, Error, "Received a cancel request for an unknown order {}. " "This should not happen and likely indicates a serious bug. ", ev.key().value()); } } -} +} -void OrderManager::on_crack_order(const mercury::Update &m) -{ +void OrderManager::on_crack_order(const mercury::Update &m) { if (m.events) - for (auto const &ev: *m.events) { + for (auto const &ev : *m.events) { auto k = ev.key(); auto it = me->orders.find(k); - if (it != me->orders.end()) + if (it != me->orders.end()) it->second.order->on_crack(); else { - LOG(OrderMan,Error, + LOG(OrderMan, Error, "Received a crack request for an unknown order {}. " "This should not happen and likely indicates a serious bug. ", ev.key().value()); } } -} +} -void OrderManager::on_gateway_state(const mercury::Update &m) -{ +void OrderManager::on_gateway_state( + const mercury::Update &m) { if (m.events) for (auto ev : *m.events) me->services_data.gw_connected = ev.is_connected; } -void OrderManager::on_new_fix_buffer(const mercury::Update &m) -{ +void OrderManager::on_new_fix_buffer( + const mercury::Update &m) { if (m.events) for (auto ev : *m.events) - free_buffers().insert(free_buffers().end(), - ev.buffers.begin(), ev.buffers.end()); + free_buffers().insert(free_buffers().end(), ev.buffers.begin(), + ev.buffers.end()); } -void OrderManager::on_timer(const mercury::Update &m) -{ +void OrderManager::on_timer(const mercury::Update &m) { if (m.events) for (auto ev : *m.events) me->services_data.last_timer_ev = ev; } - -std::vector &OrderManager::free_buffers() -{return me->services_data.free_buffers;} - -}} +std::vector &OrderManager::free_buffers() { + return me->services_data.free_buffers; +} +} +}