From 7de639eb66b462346bd44eef614d99bafa4dc0da Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 6 Nov 2017 09:04:54 -0500 Subject: [PATCH 01/29] Build tweaks. --- tools/linux_control/build_in_docker.sh | 3 +++ tools/setup_builds.sh | 16 +++++++--------- 2 files changed, 10 insertions(+), 9 deletions(-) create mode 100644 tools/linux_control/build_in_docker.sh diff --git a/tools/linux_control/build_in_docker.sh b/tools/linux_control/build_in_docker.sh new file mode 100644 index 000000000..4d152e8ea --- /dev/null +++ b/tools/linux_control/build_in_docker.sh @@ -0,0 +1,3 @@ +#!/bin/bash +cid=`docker ps | grep bluetradingsystems/linux_docker | awk '{print $1}'` +docker exec $cid /bin/bash -c "cd build/clang_debug/ && ninja" diff --git a/tools/setup_builds.sh b/tools/setup_builds.sh index 39fc31d9d..93531f3df 100755 --- a/tools/setup_builds.sh +++ b/tools/setup_builds.sh @@ -6,20 +6,18 @@ cd $DIR/../build/ rm -rf ninja_debug mkdir ninja_debug cd ninja_debug -cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ ../.. +cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ../.. cd .. rm -rf ninja_release mkdir ninja_release cd ninja_release -cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=g++ ../.. +cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER=g++ -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ../.. cd .. -if hash rtags 2>/dev/null; then - rm -rf rtags_ninja - mkdir rtags_ninja - cd rtags_ninja - cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER=rtags ../.. - cd .. -fi +rm -rf clang_debug +mkdir clang_debug +cd clang_debug +cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ../.. +cd .. From f787a9018e810d203771dfee0574d3fe013537ac Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 6 Nov 2017 09:05:07 -0500 Subject: [PATCH 02/29] Added utility to read PB's from string. --- src/lib/utils/PBUtils.h | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/src/lib/utils/PBUtils.h b/src/lib/utils/PBUtils.h index e8f5932bc..793c10e9c 100755 --- a/src/lib/utils/PBUtils.h +++ b/src/lib/utils/PBUtils.h @@ -3,6 +3,7 @@ #include #include #include "lib/utils/datetime.h" +#include "lib/utils/bts_assert.h" #include "bts_export.h" @@ -24,6 +25,13 @@ template bool from_string(const std::string &str, T*out) return google::protobuf::TextFormat::ParseFromString (str,out); } +template T from_string(const std::string &str) +{ + T result; + bts_assert(google::protobuf::TextFormat::ParseFromString (str,&result)); + return result; +} + }} } From c324eec7c180c1d0f0e0459d2559c64da5ed7e65 Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 6 Nov 2017 09:05:38 -0500 Subject: [PATCH 03/29] Refactored main.cpp slightly. --- src/server/sparkd/cmds/CmdRegistry.h | 4 ++++ src/server/sparkd/main.cpp | 6 ------ 2 files changed, 4 insertions(+), 6 deletions(-) diff --git a/src/server/sparkd/cmds/CmdRegistry.h b/src/server/sparkd/cmds/CmdRegistry.h index bab3ea91c..2a9398019 100755 --- a/src/server/sparkd/cmds/CmdRegistry.h +++ b/src/server/sparkd/cmds/CmdRegistry.h @@ -7,6 +7,10 @@ #include #include "lib/utils/bts_assert.h" +#define BEGIN_CMD +#define REGISTER(CMD) bts::cmd::CmdRegistry::register_cmd(#CMD) +#define END_CMD return bts::cmd::CmdRegistry::dispatch(argc, argv) + namespace bts { namespace cmd { diff --git a/src/server/sparkd/main.cpp b/src/server/sparkd/main.cpp index dcee14437..61139cd7e 100644 --- a/src/server/sparkd/main.cpp +++ b/src/server/sparkd/main.cpp @@ -1,12 +1,7 @@ -#include "lib/logging/logging.h" #include "lib/os/os.h" #include "lib/utils/init_spark_lib.h" #include "server/sparkd/cmds/CmdRegistry.h" -#define BEGIN_CMD -#define REGISTER(CMD) bts::cmd::CmdRegistry::register_cmd(#CMD) -#define END_CMD return bts::cmd::CmdRegistry::dispatch(argc, argv) - // to add a command add the header here and the the REGISTER call below // don't touch this file except to add commands. #include "server/sparkd/cmds/Benchmark.h" @@ -21,7 +16,6 @@ int main(int argc, char **argv) { using namespace bts; - os::set_thread_name("main"); utils::init_spark_lib(); From b2a4ae0bc027c13218462a0c61d493bb6fa5cbfb Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 10 Nov 2017 09:36:59 -0500 Subject: [PATCH 04/29] Spark-280 pimpl --- .../spreader_orders/ISpreaderStateWorker.h | 6 +- .../spreader_orders/SpreaderOrder.cpp | 297 ++++++------------ .../orderman/spreader_orders/SpreaderOrder.h | 75 ++--- .../spreader_orders/SpreaderOrderBase.cpp | 2 + .../spreader_orders/SpreaderOrderBase.h | 5 +- .../SpreaderEndStateWorker.cpp | 5 +- .../spreader_states/SpreaderEndStateWorker.h | 4 +- .../SpreaderStartStateWorker.cpp | 32 +- .../SpreaderStartStateWorker.h | 8 +- .../spreader_states/SpreaderState.h | 18 ++ ...SpreaderWaitingForCancelAllStateWorker.cpp | 7 +- .../SpreaderWaitingForCancelAllStateWorker.h | 4 +- ...SpreaderWaitingForFirstConnStateWorker.cpp | 84 ++++- .../SpreaderWaitingForFirstConnStateWorker.h | 11 +- .../SpreaderWorkingStateWorker.cpp | 14 +- .../SpreaderWorkingStateWorker.h | 4 +- .../orderman/tests/spreader_order_tests.cpp | 10 +- .../sparkd/spreader/SingleLegQuoter.cpp | 2 +- .../sparkd/spreader/SpreaderBookkeepingData.h | 25 +- src/server/sparkd/spreader/SpreaderLegData.h | 4 +- .../quoter_states/QuoterStartStateWorker.cpp | 2 +- 21 files changed, 292 insertions(+), 327 deletions(-) create mode 100644 src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h diff --git a/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h b/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h index 54aefdf17..8b37e49e9 100644 --- a/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h @@ -1,20 +1,22 @@ #pragma once - +#include "lib/utils/bts_chrono.h" #include "lib/domain_model/Security.pb.h" #include "lib/api/services/OrderService.pb.h" #include "lib/sparkproto/SparkProtos.pb.h" #include "server/sparkd/orderman/utils/orderman_utils.h" #include "server/sparkd/spreader/SpreaderLegData.h" // fix this (not needed) +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h" namespace bts { namespace orderman { class SpreaderOrder; -class TimeStamp; class Book; class ISpreaderStateWorker { public: virtual void build_once (SpreaderOrder* spreader_order) = 0; + virtual SpreaderState state() const = 0; + virtual const std::string& state_text () const = 0; //virtual SpreaderOrder::State state() const = 0; // called once and only once, before any other calls. // the spreaderoder will be in the start stat diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index 18c8bb7ea..6fe456f09 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -8,185 +8,138 @@ #include "server/sparkd/spreader/LegPropertyData.h" #include "server/sparkd/spreader/SpreaderLegData.h" #include "server/sparkd/spreader/SpreaderBookkeepingData.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h" namespace bts { namespace orderman { - -struct SpreaderOrder::PImpl -{ - PImpl(bool resurrected_arg, - const api::orderman::CreateOrderRequest& create_order_request_arg, - securities::ISecurityDB& db_arg, - OrderKey order_key, - api::orderman::OrderStatus status, - Price price, - Quantity quantity, - std::string const &reject_msg) - : - resurrected (resurrected_arg), - state (State::START), - create_order_request (create_order_request_arg), - db (db_arg), - report_message (ReportMessage (order_key, status, price, quantity, reject_msg)) - {} - const bool resurrected; - State state; - const api::orderman::CreateOrderRequest create_order_request; - securities::ISecurityDB& db; - SpreaderBookkeepingData bookkeeping_data; - ReportMessage report_message; - ISpreaderStateWorker* state_worker; - SpreaderStartStateWorker start_state_worker; - SpreaderWaitingForFirstConnStateWorker waiting_for_first_conn_state_worker; - SpreaderWorkingStateWorker working_state_worker; - SpreaderWaitingForCancelAllStateWorker waiting_for_cancel_all_state_worker; - SpreaderEndStateWorker end_state_worker; -}; - SpreaderOrder::SpreaderOrder(securities::ISecurityDB &db, NativeOrderFactory &f, const api::orderman::OrderState& os) : SpreaderOrderBase(db, f, os), - me(new PImpl(true, api::orderman::CreateOrderRequest(), db, OrderKey (0), os.order_status(), - Price(os.spreader().price()), Quantity(os.spreader().quantity()), os.reject_msg())) + _active(false), + _create_order_request (api::orderman::CreateOrderRequest()), + _state_worker(nullptr) { - LOG(OrderMan, Diag, "recovered SpreaderOrder {} from disk",os.order_key() ); + LOG(OrderMan, Diag, "SpreaderOrder.cons recovered from disk, key: {}", os.order_key() ); } - SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db, NativeOrderFactory& f, OrderKey k, const api::orderman::CreateOrderRequest& cor) : SpreaderOrderBase(db, f, k, cor), - me(new PImpl(false, cor, db, k, api::orderman::OS_UNACKNOWLEDGED, Price(cor.spreader().price()), - Quantity(cor.spreader().quantity()), std::string(""))) + _active (true), + _create_order_request (cor), + _state_worker(nullptr) { - LOG(OrderMan, Diag, "creating new SpreaderOrder. request: {}", utils::pb::to_string(cor)); + LOG(OrderMan, Diag, "SpreaderOrder.cons request: {} key: {}", utils::pb::to_string(cor), k.value()); bts_assert(cor.has_spreader()); bts_assert(cor.spreader().security().has_synthetic()); _transform_to_START (); } - -SpreaderOrder::~SpreaderOrder () {} +SpreaderOrder::~SpreaderOrder () {} void SpreaderOrder::init() { - if (me->resurrected) return; - LOG(OrderMan, Diag, "SpreaderOrder.Init"); - me->state_worker->init(); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.init key: {}", key().value()); + _state_worker->init(); } void SpreaderOrder::on_connect() { - if (me->resurrected) return; - LOG(OrderMan, Diag, "Spreaderorder.on_connect"); - me->state_worker->on_connect (); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_connect key: {}", key().value()); + _state_worker->on_connect (); } void SpreaderOrder::on_disconnect() { - if (me->resurrected) return; - LOG(OrderMan,Diag,"on_disconnect"); - me->state_worker->on_disconnect(); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_disconnect key: {}", key().value()); + _state_worker->on_disconnect(); } - void SpreaderOrder::on_update(const api::orderman::UpdateSpreaderOrder& u) { - LOG(OrderMan,Diag,"on_update SpreaderOrder: {}",key().value()); - if (me->resurrected) return; - me->state_worker->on_update(u); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_update key: {}", key().value()); + _state_worker->on_update(u); } - void SpreaderOrder::on_cancel(const api::orderman::CancelSpreaderOrder& c) { - LOG(OrderMan,Diag,"on_cancel SpreaderOrder. order {}",key().value()); - if (me->resurrected) return; - me->state_worker->on_cancel(c); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_cancel key: {}", key().value()); + _state_worker->on_cancel(c); } - void SpreaderOrder::on_book(TickToTradeCorID cid, Book const& book) { - if (me->resurrected) return; + if (!_active) return; LOG(Latency, Info, "on_book {} {}", cid, utils::TimeStamp::now().to_uint64()); - me->state_worker->on_book (cid, book); + _state_worker->on_book (cid, book); } - -void SpreaderOrder::on_time(const bts::TimeStamp&) +void SpreaderOrder::on_time(const bts::TimeStamp& ts) { - if (me->resurrected) return; + if (!_active) return; + _state_worker->on_time (ts); } - void SpreaderOrder::on_child_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const *error_msg) { - if (me->resurrected) return; + if (!_active) return; static std::string empty; - LOG(OrderMan,Diag, "SpreaderOrder.on_child_update " "k: {} status: {} filled_qty: {} avg_price: {} reject_msg: {}", + LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} status: {} filled_qty: {} avg_price: {} reject_msg: {}", order_key.value(), status, filled_quantity.value(), average_price.value(), error_msg == nullptr ? empty : *error_msg); - SpreaderLegData* leg_data_ptr = me->bookkeeping_data.find_leg_from_quoter_orderkey(order_key); + SpreaderLegData* leg_data_ptr = _bookkeeping_data.find_leg_from_quoter_orderkey(order_key); if (leg_data_ptr != nullptr) { SpreaderLegData& leg_data = *leg_data_ptr; - LOG(OrderMan,Diag, "Order {} is a quoting order, forwarding", order_key.value()); + LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} is a quoting order, forwarding", order_key.value()); if (error_msg != nullptr) - me->state_worker->on_quoter_order_error (leg_data, status, filled_quantity, average_price, error_msg); + _state_worker->on_quoter_order_error (leg_data, status, filled_quantity, average_price, error_msg); else { if (filled_quantity.value() != 0) - me->state_worker->on_quoter_order_fill (leg_data, status, filled_quantity, average_price); + _state_worker->on_quoter_order_fill (leg_data, status, filled_quantity, average_price); else - me->state_worker->on_quoter_order_status_update (leg_data, status); + _state_worker->on_quoter_order_status_update (leg_data, status); } } else { // should be a hedge order then - SpreaderHedgerData* hedger_data = me->bookkeeping_data.find_hedger_from_orderkey(order_key); + SpreaderHedgerData* hedger_data = _bookkeeping_data.find_hedger_from_orderkey(order_key); if (hedger_data != nullptr) { - LOG(OrderMan,Diag, "Order {} is a hedging order, forwarding", order_key.value()); + LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} is a hedging order, forwarding", order_key.value()); if (error_msg != nullptr) - me->state_worker->on_hedger_order_error (order_key, status, filled_quantity, average_price, error_msg); + _state_worker->on_hedger_order_error (order_key, status, filled_quantity, average_price, error_msg); else - me->state_worker->on_hedger_order_update (order_key, status, filled_quantity, average_price); + _state_worker->on_hedger_order_update (order_key, status, filled_quantity, average_price); } else - { - // uknown order, should be treater as an error condition bts_assert_msg (false, "This order was not initiated in this spreader"); - } } } - void SpreaderOrder::on_external_error(const std::string& reason) { - if (me->resurrected) return; + if (!_active) return; LOG(OrderMan,Warn, "on_external_error SpreaderOrder. msg: {}", reason); - me->state_worker->on_external_error (reason); + _state_worker->on_external_error (reason); } - const orderman::Book& SpreaderOrder::get_book(size_t leg_index) const { - return me->bookkeeping_data.get_leg_data(leg_index).book(); + return _bookkeeping_data.get_leg_data(leg_index).book(); } const LegPropertyData& SpreaderOrder::get_leg_data(size_t leg_index) const { - return me->bookkeeping_data.get_leg_data(leg_index).leg_property_data; + return _bookkeeping_data.get_leg_data(leg_index).leg_property_data; } - void SpreaderOrder::_construct_bookkeeping_data_and_quoters() { std::vector leg_data_vector; //creating the basic data ISpreaderManager& me_ref = *this; - const bts::api::orderman::CreateSpreaderOrder& cor = me->create_order_request.spreader(); + const bts::api::orderman::CreateSpreaderOrder& cor = _create_order_request.spreader(); spark::ExecutionStrategy execution_strategy = cor.execution_strategy(); const bts::api::Security& sec = cor.security(); size_t leg_idx = 0; @@ -200,7 +153,7 @@ void SpreaderOrder::_construct_bookkeeping_data_and_quoters() LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side); // setting up the order for this leg bts::SecurityKey leg_key = bts::SecurityKey (leg_property_data.security_key()); - api::Security const* db_sec = me->db.resolve (leg_key); + api::Security const* db_sec = _db().resolve (leg_key); bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(*db_sec, leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory(); LOG(OrderMan,Diag,"Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), key().value()); @@ -210,75 +163,43 @@ void SpreaderOrder::_construct_bookkeeping_data_and_quoters() leg_idx++; } bts_assert(leg_data_vector.size() > 0); - me->bookkeeping_data = SpreaderBookkeepingData(sec, leg_data_vector); + _bookkeeping_data = SpreaderBookkeepingData(leg_data_vector); } - -void SpreaderOrder::_subscribe_to_marketdata() -{ - for (size_t index = 0; index < me->bookkeeping_data.count(); index++) - { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(index); - bts::SecurityKey leg_key = bts::SecurityKey (leg_data.leg_property_data.security_key()); - api::Security const* db_sec = me->db.resolve (leg_key); - subscribe_to_md (*db_sec); - } -} - -void SpreaderOrder::_init_quoters () -{ - for (size_t index = 0; index < me->bookkeeping_data.count(); index++) - { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(index); - if (leg_data.leg_property_data.is_active_quoting()) - leg_data.quoter().init(); - } -} - void SpreaderOrder::_transform_to_START() { - me->state = State::START; - me->state_worker = &(me->start_state_worker); - me->state_worker->build_once (this); + bts_assert (_state_worker == nullptr); + _switch_state (&_start_state_worker); report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } - void SpreaderOrder::_transform_to_WAITING_FOR_FIRST_CONNECTION() { - bts_assert(me->state == State::START); - me->state = State::WAITING_FOR_FIRST_CONNECT; - me->state_worker = &(me->waiting_for_first_conn_state_worker); - me->state_worker->build_once (this); + bts_assert(_state_worker->state() == SpreaderState::START); + _switch_state(&_waiting_for_first_conn_state_worker); report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderOrder::_transform_to_WORKING() { - bts_assert(me->state == State::WAITING_FOR_FIRST_CONNECT); - me->state = State::WORKING; - me->state_worker = &(me->working_state_worker); - me->state_worker->build_once (this); + bts_assert(_state_worker->state() == SpreaderState::WAITING_FOR_FIRST_CONNECT); + _switch_state(&_working_state_worker); report_state (api::orderman::OrderStatus::OS_NEW); } void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL() { - bts_assert(me->state == State::WORKING); - me->state = State::WAITING_FOR_CANCEL_ALL; - me->state_worker = &(me->waiting_for_cancel_all_state_worker); - me->state_worker->build_once (this); + bts_assert(_state_worker->state() == SpreaderState::WORKING); + _switch_state(&_waiting_for_cancel_all_state_worker); report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); } void SpreaderOrder::_transform_to_END() { - bts_assert(me->state == State::WORKING || me->state == State::WAITING_FOR_CANCEL_ALL); - me->state = State::END; - me->state_worker = &(me->end_state_worker); - me->state_worker->build_once (this); - report_state(); + bts_assert(_state_worker->state() != SpreaderState::END); + _switch_state(&_end_state_worker); + report_state (api::orderman::OrderStatus::OS_DONE); } void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (cancel_quotes) { if (leg_data.leg_property_data.is_active_quoting()) @@ -294,9 +215,9 @@ void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) } bool SpreaderOrder::_all_quoter_orders_in_terminal_state() { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data.is_active_quoting()) if (!leg_data.quoter().is_terminal_state()) return false; @@ -306,9 +227,9 @@ bool SpreaderOrder::_all_quoter_orders_in_terminal_state() // same as _all_quoter_orders_in_terminal_state, for hedgers bool SpreaderOrder::_all_hedger_orders_in_terminal_state() { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) { SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); @@ -320,17 +241,17 @@ bool SpreaderOrder::_all_hedger_orders_in_terminal_state() } void SpreaderOrder::_terminate_quoters () { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); leg_data.quoter().terminate(); } } void SpreaderOrder::_terminate_hedgers () { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) { SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); @@ -340,21 +261,20 @@ void SpreaderOrder::_terminate_hedgers () } bool SpreaderOrder::_quoters_can_accept_modification () { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data.is_active_quoting()) if (!leg_data.quoter().accept_modifications()) return false; } return true; } - void SpreaderOrder::_send_hedge(size_t, Price, Quantity, size_t) { -// for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) +// for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) // { -// SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); +// SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); // for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) // { // SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); @@ -370,69 +290,38 @@ void SpreaderOrder::_compute_hedge_price_quantity(size_t, Price&, Quantity&) { } - -void SpreaderOrder::report_state() -{ -// report_state_change(SpreaderOrderState{ -// me->report_message.status, -// me->price, -// me->quantity, -// me->reject_msg.empty() ? nullptr : &me->reject_msg -// }); -} - void SpreaderOrder::report_state (api::orderman::OrderStatus order_status) { - report_state_change(SpreaderOrderState{ - order_status, - me->report_message.price, - me->report_message.quantity, - nullptr - }); + report_state_change(SpreaderOrderState{ + order_status, + _bookkeeping_data.price(), + _bookkeeping_data.quantity(), + nullptr + }); } - void SpreaderOrder::report_state (api::orderman::OrderStatus order_status, std::string& message) { -report_state_change(SpreaderOrderState{ - order_status, - me->report_message.price, - me->report_message.quantity, - message.empty() ? nullptr : &message - }); + report_state_change(SpreaderOrderState{ + order_status, + _bookkeeping_data.price(), + _bookkeeping_data.quantity(), + message.empty() ? nullptr : &message + }); } - -bool SpreaderOrder::can_resolve_securties () +void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state) { - const bts::api::orderman::CreateSpreaderOrder& cor = me->create_order_request.spreader(); - const bts::api::Security& sec = cor.security(); - for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) - { - const bts::api::ContractLeg& leg = *it; - bts::SecurityKey leg_key = bts::SecurityKey (leg.security().id()); - api::Security const * db_sec = me->db.resolve (leg_key); - if (db_sec == nullptr) - return false; - } - return true; + LOG(OrderMan, Diag, "SpreaderOrder::_switch_state key: {}, {} -> {} ", key().value(), (_state_worker == nullptr ? "NULL" : _state_worker->state_text()), new_state->state_text()); + _state_worker = new_state; + _state_worker->build_once (this); } - -void SpreaderOrder::update_spreader_order (Price price, Quantity quantity) -{ - me->report_message.price = price; - me->report_message.quantity = quantity; -} - -SpreaderBookkeepingData& SpreaderOrder::bookkeeping_data () {return me->bookkeeping_data;} +SpreaderBookkeepingData& SpreaderOrder::bookkeeping_data () {return _bookkeeping_data;} /*******************************************************************************/ -/******************Functions to Help Testing************************************/ - -SpreaderOrder::State SpreaderOrder::test_only_func_state() {return me->state;} - +/***************************Functions to Help Testing****************************/ +SpreaderState SpreaderOrder::test_only_func_state() {return _state_worker->state();} SpreaderLegData& SpreaderOrder::test_only_func_leg_data (size_t index) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data (index); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data (index); return leg_data; } - -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index 75676424c..105543b6b 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -1,73 +1,40 @@ #pragma once #include +#include "lib/utils/bts_chrono.h" #include "lib/domain_model/Security.pb.h" #include "lib/api/services/OrderService.pb.h" #include "lib/sparkproto/SparkProtos.pb.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h" +#include "server/sparkd/securities/SecurityDB.h" #include "server/sparkd/spreader/SpreaderBookkeepingData.h" #include "server/sparkd/spreader/ISpreaderManager.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h" namespace bts { namespace api {namespace orderman {class OrderState; class CreateSpreaderOrder;}} -namespace securities {class SecurityDB;} +//namespace securities {class SecurityDB;} namespace orderman { class Book; class NativeOrderFactory; - class SpreaderOrder : public SpreaderOrderBase, public ISpreaderManager { public: - enum State - { - // pre init state - START, - // once init happens, it waits for the first connection - WAITING_FOR_FIRST_CONNECT, - // after the first connection, the general waiting state - WORKING, - // waiting for all quoters and hedgers to be done - WAITING_FOR_CANCEL_ALL, - // end state - END - }; - // state for the outgoing message is kept here. - // (could have been laid flat in the PImpl but this - // keeps the relevant data together) - // this mirrors the args of report_state_change - // call (except that the order_key is also piggybacked - // here since it belongs to the same family) - // - class ReportMessage - { - public: - const OrderKey order_key; - api::orderman::OrderStatus status; - Price price; - Quantity quantity; - std::string reject_msg; - ReportMessage (OrderKey order_key_arg, api::orderman::OrderStatus status_arg, - Price price_arg, Quantity quantity_arg, std::string reject_msg_arg) - : - order_key (order_key_arg), - status (status_arg), - price (price_arg), - quantity (quantity_arg), - reject_msg (reject_msg_arg) - {} - }; // old order recovered from disk SpreaderOrder(securities::ISecurityDB&, NativeOrderFactory&, api::orderman::OrderState const&); - // new order created by user SpreaderOrder(securities::ISecurityDB&, NativeOrderFactory&, OrderKey, api::orderman::CreateOrderRequest const&); - ~SpreaderOrder(); // called once and only once, before any other calls. // the spreaderoder will be in the start state @@ -87,7 +54,7 @@ public: void on_cancel(api::orderman::CancelSpreaderOrder const&); // on market data update (support late joiners) void on_book(TickToTradeCorID corid,Book const&); - void on_time(const TimeStamp&); + void on_time(const bts::TimeStamp&); // called whenever a child order updates, as long as the spreader // is not in a terminal state. void on_child_update(OrderKey child_k, @@ -103,12 +70,10 @@ public: const orderman::Book& get_book(size_t leg_index) const override; const LegPropertyData& get_leg_data(size_t leg_index) const override; // this is exposed for testing reasons only - State test_only_func_state (); + SpreaderState test_only_func_state (); SpreaderLegData& test_only_func_leg_data (size_t index); private: void _construct_bookkeeping_data_and_quoters (); - void _subscribe_to_marketdata (); - void _init_quoters (); void _transform_to_START(); void _transform_to_WAITING_FOR_FIRST_CONNECTION(); void _transform_to_WORKING(); @@ -130,20 +95,24 @@ private: Price filled_price, Quantity filled_quantity, size_t hedged_index, Price& hedge_price, Quantity& hedge_quantity); - void report_state(); void report_state (api::orderman::OrderStatus order_status); void report_state (api::orderman::OrderStatus order_status, std::string& message); - bool can_resolve_securties(); - void update_spreader_order (Price price, Quantity quantity); SpreaderBookkeepingData& bookkeeping_data (); + void _switch_state (ISpreaderStateWorker* new_state); private: - struct PImpl; - std::unique_ptr me; + const bool _active; + const api::orderman::CreateOrderRequest _create_order_request; + SpreaderBookkeepingData _bookkeeping_data; friend class SpreaderStartStateWorker; friend class SpreaderWaitingForFirstConnStateWorker; friend class SpreaderWorkingStateWorker; friend class SpreaderWaitingForCancelAllStateWorker; friend class SpreaderEndStateWorker; + ISpreaderStateWorker* _state_worker; + SpreaderStartStateWorker _start_state_worker; + SpreaderWaitingForFirstConnStateWorker _waiting_for_first_conn_state_worker; + SpreaderWorkingStateWorker _working_state_worker; + SpreaderWaitingForCancelAllStateWorker _waiting_for_cancel_all_state_worker; + SpreaderEndStateWorker _end_state_worker; }; - -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp index 8a61812a0..c64b89f56 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp @@ -134,4 +134,6 @@ void SpreaderOrderBase::report_state_change(SpreaderOrderState const&sos) } } +securities::ISecurityDB& SpreaderOrderBase::_db() {return me->sec_db;} + }} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h index f8e1c719f..ec0826d6c 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h @@ -106,8 +106,6 @@ public: _key = rhs._key; return *this; } - - private: NativeOrder* _order; event_grid::Signal _create; @@ -160,7 +158,8 @@ public: ChildFactory get_child_factory(const api::Security&,api::Side, api::orderman::ChildOrderKind); - +protected: + securities::ISecurityDB& _db(); private: struct PImpl; std::unique_ptr me; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp index 17f3c04b7..7197fba75 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp @@ -4,12 +4,13 @@ namespace bts { namespace orderman { -SpreaderEndStateWorker::SpreaderEndStateWorker () {} +SpreaderEndStateWorker::SpreaderEndStateWorker () : _state_text ("END") {} +SpreaderState SpreaderEndStateWorker::state() const {return SpreaderState::END;} +const std::string& SpreaderEndStateWorker::state_text () const {return _state_text;} void SpreaderEndStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderEndStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderEndStateWorker::init () { // all error-free order status updates in this state (and the next) diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h index 9b167956d..1315b799f 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h @@ -10,10 +10,12 @@ class SpreaderEndStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderEndStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp index 4d6d65953..03e06e0d8 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp @@ -4,68 +4,62 @@ namespace bts { namespace orderman { -SpreaderStartStateWorker::SpreaderStartStateWorker () {} +SpreaderStartStateWorker::SpreaderStartStateWorker (): _state_text ("START") {} +SpreaderState SpreaderStartStateWorker::state() const {return SpreaderState::START;} +const std::string& SpreaderStartStateWorker::state_text () const {return _state_text;} void SpreaderStartStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderStartStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderStartStateWorker::init () { - // all error-free order status updates in this state (and the next) - // are OS_PENDING_NEW. order goes to OS_NEW once it is WORKING - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_NEW); _spreader->_transform_to_WAITING_FOR_FIRST_CONNECTION (); } void SpreaderStartStateWorker::on_connect() { - bts_assert_msg(false, "Illegal Spreader operation {START,on_connect}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_connect is an illegal operation"); } void SpreaderStartStateWorker::on_disconnect() { - bts_assert_msg(false, "Illegal Spreader operation {START,on_disconnect}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_disconnect is an illegal operation"); } void SpreaderStartStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update) { - _spreader->update_spreader_order (Price(order_update.price()), Quantity (order_update.quantity())); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_NEW); + _spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity())); } void SpreaderStartStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); _spreader->_transform_to_END(); } void SpreaderStartStateWorker::on_book(TickToTradeCorID, Book const&) { - bts_assert_msg (false, "Illegal Spreader operation {state,event} START,on_book"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_book is an illegal operation"); } void SpreaderStartStateWorker::on_time(const TimeStamp&) { } void SpreaderStartStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_quoter_order_error}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_quoter_order_error is an illegal operation"); } void SpreaderStartStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_quoter_order_fill}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_quoter_order_fill is an illegal operation"); } void SpreaderStartStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_quoter_order_status_update}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_quoter_order_status_update is an illegal operation"); } void SpreaderStartStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_hedger_order_error}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_hedger_order_error is an illegal operation"); } void SpreaderStartStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_hedger_order_upate}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_hedger_order_update is an illegal operation"); } -void SpreaderStartStateWorker::on_external_error(std::string const& err_msg) +void SpreaderStartStateWorker::on_external_error(std::string const&) { - std::string msg = err_msg; - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg); _spreader->_transform_to_END (); } void SpreaderStartStateWorker::on_check_termination () diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h index 816fc7118..d58b674cc 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h @@ -5,15 +5,19 @@ namespace bts { namespace orderman { class SpreaderOrder; - +//this is the start state which is where the spreader +//gets right after the constructor. it leaves this state +// on an init calls class SpreaderStartStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderStartStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h new file mode 100644 index 000000000..650a3f8d0 --- /dev/null +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h @@ -0,0 +1,18 @@ +#pragma once + +namespace bts{ +namespace orderman{ +enum class SpreaderState +{ + // pre init state + START, + // once init happens, it waits for the first connection + WAITING_FOR_FIRST_CONNECT, + // after the first connection, the general waiting state + WORKING, + // waiting for all quoters and hedgers to be done + WAITING_FOR_CANCEL_ALL, + // end state + END +}; +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp index 0633b4930..03f8df81c 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp @@ -4,12 +4,13 @@ namespace bts { namespace orderman { -SpreaderWaitingForCancelAllStateWorker::SpreaderWaitingForCancelAllStateWorker () {} +SpreaderWaitingForCancelAllStateWorker::SpreaderWaitingForCancelAllStateWorker (): _state_text ("WAITING_FOR_CANCEL_ALL") {} +SpreaderState SpreaderWaitingForCancelAllStateWorker::state() const {return SpreaderState::WAITING_FOR_CANCEL_ALL;} +const std::string& SpreaderWaitingForCancelAllStateWorker::state_text () const {return _state_text;} void SpreaderWaitingForCancelAllStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderWaitingForCancelAllStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderWaitingForCancelAllStateWorker::init () { bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_CANCEL_ALL,init}"); @@ -69,7 +70,7 @@ void SpreaderWaitingForCancelAllStateWorker::on_check_termination() { if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) { - _spreader->report_state (); // TODO, figure out if it was filled or cxl'ed + _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); // TODO, figure out if it was filled or cxl'ed _spreader->_transform_to_END (); } } diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h index cb900fe6f..74f370643 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h @@ -10,10 +10,12 @@ class SpreaderWaitingForCancelAllStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderWaitingForCancelAllStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp index 58d76750a..66aae2a74 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp @@ -1,27 +1,29 @@ #include "SpreaderWaitingForFirstConnStateWorker.h" #include "server/sparkd/orderman/spreader_orders/SpreaderOrder.h" +#include "server/sparkd/spreader/SpreaderUtils.h" +#include "server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h" namespace bts { namespace orderman { -SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker () {} +SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker (): _state_text ("WAITING_FOR_FIRST_CONNECT") {} +SpreaderState SpreaderWaitingForFirstConnStateWorker::state() const {return SpreaderState::WAITING_FOR_FIRST_CONNECT;} +const std::string& SpreaderWaitingForFirstConnStateWorker::state_text () const {return _state_text;} void SpreaderWaitingForFirstConnStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderWaitingForFirstConnStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderWaitingForFirstConnStateWorker::init () { bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,init}"); } void SpreaderWaitingForFirstConnStateWorker::on_connect() { - if (_spreader->can_resolve_securties ()) + if (_can_resolve_securities ()) { _spreader->_construct_bookkeeping_data_and_quoters (); - _spreader->_init_quoters(); - _spreader->_subscribe_to_marketdata (); - _spreader->report_state (api::orderman::OrderStatus::OS_NEW); + _init_quoters (); + _subscribe_to_marketdata (); _spreader->_transform_to_WORKING (); } else @@ -38,7 +40,7 @@ void SpreaderWaitingForFirstConnStateWorker::on_disconnect() } void SpreaderWaitingForFirstConnStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update) { - _spreader->update_spreader_order (Price(order_update.price()), Quantity (order_update.quantity())); + _spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity())); _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderWaitingForFirstConnStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) @@ -73,12 +75,74 @@ void SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update(OrderKey, ap { bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_hedger_order_upate}"); } -void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const& err_msg) +void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const&) { - std::string msg = err_msg; - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg); _spreader->_transform_to_END (); } void SpreaderWaitingForFirstConnStateWorker::on_check_termination() {} +void SpreaderWaitingForFirstConnStateWorker::_init_quoters () +{ + for (size_t index = 0; index < _spreader->_bookkeeping_data.count(); index++) + { + SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(index); + if (leg_data.leg_property_data.is_active_quoting()) + leg_data.quoter().init(); + } +} +bool SpreaderWaitingForFirstConnStateWorker::_can_resolve_securities () +{ + const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader(); + const bts::api::Security& sec = cor.security(); + for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) + { + const bts::api::ContractLeg& leg = *it; + bts::SecurityKey leg_key = bts::SecurityKey (leg.security().id()); + api::Security const* db_sec = _spreader->_db().resolve (leg_key); + if (db_sec == nullptr) + return false; + } + return true; +} +void SpreaderWaitingForFirstConnStateWorker::_subscribe_to_marketdata() +{ + for (size_t index = 0; index < _spreader->_bookkeeping_data.count(); index++) + { + SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(index); + bts::SecurityKey leg_key = bts::SecurityKey (leg_data.leg_property_data.security_key()); + api::Security const* db_sec = _spreader->_db().resolve (leg_key); + _spreader->subscribe_to_md (*db_sec); + } +} +void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quoters() +{ + std::vector leg_data_vector; + //creating the basic data + ISpreaderManager& me_ref = *_spreader; + const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader(); + spark::ExecutionStrategy execution_strategy = cor.execution_strategy(); + const bts::api::Security& sec = cor.security(); + size_t leg_idx = 0; + for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) + { + // immutable property data for this leg + const bts::api::ContractLeg& leg = *it; + auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id()); + bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end()); + api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg); + LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side); + // setting up the order for this leg + bts::SecurityKey leg_key = bts::SecurityKey (leg_property_data.security_key()); + api::Security const* db_sec = _spreader->_db().resolve (leg_key); + bts::orderman::SpreaderOrderBase::ChildFactory child_factory = _spreader->get_child_factory(*db_sec, leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); + bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory(); + LOG(OrderMan,Diag,"Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), _spreader->key().value()); + SingleLegQuoter leg_quoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order); + SpreaderLegData leg_data(leg_property_data, leg_quoter, child_order.order_key()); + leg_data_vector.push_back(leg_data); + leg_idx++; + } + bts_assert(leg_data_vector.size() > 0); + _spreader->_bookkeeping_data = SpreaderBookkeepingData(leg_data_vector); +} }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h index b41c6a50f..de10ccb1e 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h @@ -10,10 +10,12 @@ class SpreaderWaitingForFirstConnStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderWaitingForFirstConnStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; @@ -28,6 +30,13 @@ public: void on_hedger_order_update(OrderKey child_k, api::orderman::OrderStatus, Quantity filled_quantity, Price average_price) override; void on_external_error(std::string const&) override; void on_check_termination () override; +private: + void _init_quoters (); + // calls db.resolve on each leg of the spread + // and makes sure an + bool _can_resolve_securities (); + void _subscribe_to_marketdata (); + void _construct_bookkeeping_data_and_quoters (); }; }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 8778318b7..865094ca0 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -4,12 +4,13 @@ namespace bts { namespace orderman { -SpreaderWorkingStateWorker::SpreaderWorkingStateWorker () {} +SpreaderWorkingStateWorker::SpreaderWorkingStateWorker (): _state_text ("WORKING") {} +SpreaderState SpreaderWorkingStateWorker::state() const {return SpreaderState::WORKING;} +const std::string& SpreaderWorkingStateWorker::state_text () const {return _state_text;} void SpreaderWorkingStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderWorkingStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderWorkingStateWorker::init () { bts_assert_msg(false, "Illegal Spreader operation {WORKING,init}"); @@ -32,7 +33,7 @@ void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOr Price new_price (order_update.price()); Quantity new_quantity (order_update.quantity()); SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); // updating internal state - _spreader->update_spreader_order (new_price, new_quantity); + _spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity())); // updating all active quoters for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++) { @@ -43,11 +44,6 @@ void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOr // reporting state _spreader->report_state (api::orderman::OrderStatus::OS_NEW); } - else - { - // quoters were not ready, this change is rejected - _spreader->report_state (); - } } void SpreaderWorkingStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { @@ -151,7 +147,7 @@ void SpreaderWorkingStateWorker::on_check_termination() { if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) { - _spreader->report_state (); // TODO, figure out if it was filled or cxl'ed + _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); // TODO, figure out if it was filled or cxl'ed _spreader->_transform_to_END (); } } diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h index 0e989f15b..c514eef3d 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h @@ -10,10 +10,12 @@ class SpreaderWorkingStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderWorkingStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/tests/spreader_order_tests.cpp b/src/server/sparkd/orderman/tests/spreader_order_tests.cpp index a28860a5e..c93c2f5fb 100644 --- a/src/server/sparkd/orderman/tests/spreader_order_tests.cpp +++ b/src/server/sparkd/orderman/tests/spreader_order_tests.cpp @@ -233,13 +233,13 @@ void disabled_temp() do_nothing, do_nothing, do_nothing); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::START); + bts_assert (order.test_only_func_state() == SpreaderState::START); /*********************Initing the order********************/ order.init (); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::WAITING_FOR_FIRST_CONNECT); + bts_assert (order.test_only_func_state() == SpreaderState::WAITING_FOR_FIRST_CONNECT); /*********************First on_connect*********************/ order.on_connect (); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::WORKING); + bts_assert (order.test_only_func_state() == SpreaderState::WORKING); bts::orderman::SpreaderLegData& leg_data = order.test_only_func_leg_data (1); bts_assert (leg_data.quoter().test_only_func_state() == QuoterState::WAITING_FOR_SIZE); const QuoteLegPriceQuantityState& qp_state = leg_data.quoter().test_only_func_price_quantity_state (); @@ -301,12 +301,12 @@ void disabled_temp() // fill it all // cancel it // order.on_cancel (api::orderman::CancelSpreaderOrder()); - // bts_assert (order.test_only_func_state() == SpreaderOrder::State::WAITING_FOR_CANCEL_ALL); + // bts_assert (order.test_only_func_state() == SpreaderState::WAITING_FOR_CANCEL_ALL); // bts_assert (leg_data.quoter().test_only_func_state() == SingleLegQuoter::QuoterState::WAITING_FOR_CANCEL_ACK); // send cxl ack order.on_child_update (bts::orderman::OrderKey (0), api::orderman::OrderStatus::OS_CANCELED, Quantity(23), Price(2500), nullptr); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::END); + bts_assert (order.test_only_func_state() == SpreaderState::END); bts_assert (leg_data.quoter().test_only_func_state() == QuoterState::END); } } diff --git a/src/server/sparkd/spreader/SingleLegQuoter.cpp b/src/server/sparkd/spreader/SingleLegQuoter.cpp index c2c77bfc1..bbe4b852a 100644 --- a/src/server/sparkd/spreader/SingleLegQuoter.cpp +++ b/src/server/sparkd/spreader/SingleLegQuoter.cpp @@ -94,7 +94,7 @@ void SingleLegQuoter::_compute_price_quantity(Price& price, Quantity& quantity) { size_t other_leg_index = _this_leg_data.leg_index == 0 ? 1 : 0; SpreaderUtils::compute_price_quantity_2_legs (_price_quantity_state, _this_leg_data, _spreader.get_leg_data(other_leg_index), _spreader.get_book(other_leg_index), price, quantity); - } + } else _compute_price_quantity_n_legs (price, quantity); } void SingleLegQuoter::_compute_price_quantity_n_legs(Price& price, Quantity& quantity) diff --git a/src/server/sparkd/spreader/SpreaderBookkeepingData.h b/src/server/sparkd/spreader/SpreaderBookkeepingData.h index 3436d549c..ec61cf09c 100644 --- a/src/server/sparkd/spreader/SpreaderBookkeepingData.h +++ b/src/server/sparkd/spreader/SpreaderBookkeepingData.h @@ -1,6 +1,7 @@ #pragma once #include #include +#include "server/sparkd/orderman/utils/orderman_utils.h" #include "SpreaderLegData.h" namespace bts{ @@ -13,20 +14,18 @@ class SpreaderBookkeepingData private: std::vector _leg_data; boost::container::flat_map _sec_key_to_index; -public: - api::Security security; // TODO, move it out of here + Price _price; + Quantity _quantity; public: SpreaderBookkeepingData () {} - - SpreaderBookkeepingData(const api::Security& security_arg, const std::vector& leg_data) + SpreaderBookkeepingData(const std::vector& leg_data) : - _leg_data (leg_data), - security(security_arg) + _leg_data (leg_data) { for (auto it = leg_data.begin(); it != leg_data.end(); ++it) _sec_key_to_index.insert(std::pair(it->leg_property_data.security_key(), it->leg_property_data.leg_index)); } - SpreaderLegData& get_leg_data(SecurityKey security_key) + SpreaderLegData& get_leg_data (SecurityKey security_key) { boost::container::flat_map::const_iterator l_it = _sec_key_to_index.find(security_key.value()); bts_assert (l_it != _sec_key_to_index.end()); @@ -37,6 +36,11 @@ public: bts_assert(index < _leg_data.size()); return _leg_data[index]; } + const SpreaderLegData& get_leg_data (size_t index) const + { + bts_assert(index < _leg_data.size()); + return _leg_data[index]; + } size_t count() { return _leg_data.size(); } SpreaderLegData* find_leg_from_quoter_orderkey(orderman::OrderKey order_key) @@ -57,6 +61,13 @@ public: } return nullptr; } + Price price () {return _price;} + Quantity quantity () {return _quantity;} + void update_order (Price price, Quantity quantity) + { + _price = price; + _quantity = quantity; + } }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/SpreaderLegData.h b/src/server/sparkd/spreader/SpreaderLegData.h index 14bee4b18..10e094e7b 100644 --- a/src/server/sparkd/spreader/SpreaderLegData.h +++ b/src/server/sparkd/spreader/SpreaderLegData.h @@ -34,10 +34,10 @@ public: _quoter (quoter_arg), _book(), _order_update_message (SpreaderOrderUpdateMessage (order_key)), - _hedger_data_vector() {} + _hedger_data_vector() {} SingleLegQuoter& quoter() {return _quoter;} - orderman::Book& book () {return _book;} + const orderman::Book& book () const {return _book;} // called for every book update. the values // are copied by value void set_book(const orderman::Book& book_arg) {_book = book_arg;} diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp index 4720b428b..8edf2b56a 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp @@ -19,7 +19,7 @@ void QuoterStartStateWorker::init () void QuoterStartStateWorker::on_order_update (const SpreaderOrderUpdateMessage&) { // no order has been sent as yet, so there is no way to get a callback - bts_assert_msg (false, "QuoterStartStateWorker::on_order_update key: {}, is an illegal operation"); + bts_assert_msg (false, "QuoterStartStateWorker::on_order_update is an illegal operation"); } void QuoterStartStateWorker::on_book (bts::orderman::TickToTradeCorID, size_t, const bts::orderman::Book&) { From b7b3cbb59d7179370f008751fef8a28d8ece5771 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 10 Nov 2017 09:37:35 -0500 Subject: [PATCH 05/29] merging --- docker/linux | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docker/linux b/docker/linux index 41523ccab..d4a32d325 160000 --- a/docker/linux +++ b/docker/linux @@ -1 +1 @@ -Subproject commit 41523ccab74b95bb007d9b9330d52c0f9e12dd1e +Subproject commit d4a32d32592c688c3a1f042750fd3323bcdfd38a From eafa6ed68ddaadc108cb2429c60d9b0e6eabd12e Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Fri, 10 Nov 2017 11:18:45 -0500 Subject: [PATCH 06/29] Make c# api friendlier to immutable types. Rename Result.result to Result.value --- .../spark/mspark/MarketView/MarketViewVM.cs | 2 +- .../spark/mspark/Shell/Fills/FillsVM.cs | 2 +- .../Synthetic/SyntheticEditorModel.cs | 2 +- .../Shell/TimeAndSales/TimeAndSalesVM.cs | 2 +- src/client/spark/sys/api/Test/ApiTests.cs | 2 +- .../spark/sys/api/Test/HelloServiceServer.cs | 4 +- src/client/spark/sys/persist/UISettings.cs | 8 +- .../uicore/Settings/UserPersistFactory.cs | 2 +- .../spark/uicore/Shell/Login/LoginModel.cs | 6 +- .../api/Channels/QuickBusClientChannel.cs | 12 +- src/client/spark_api/api/ClientChannel.cs | 30 +-- src/client/spark_api/api/Result.cs | 82 ++++---- src/client/spark_api/api/Update.cs | 176 +++++++++--------- ...ImmutableProto.cs => IImmutableMessage.cs} | 2 +- src/lib/api/service_compiler/plugin.py | 14 +- .../templates/c#/client.pb.cs | 21 ++- .../templates/c#/immutable.pb.cs | 17 +- src/lib/sparkproto/SparkProtos.proto | 26 +-- 18 files changed, 221 insertions(+), 189 deletions(-) rename src/client/spark_api/utils/{IImmutableProto.cs => IImmutableMessage.cs} (94%) diff --git a/src/client/spark/mspark/MarketView/MarketViewVM.cs b/src/client/spark/mspark/MarketView/MarketViewVM.cs index ea2095896..704e6e473 100644 --- a/src/client/spark/mspark/MarketView/MarketViewVM.cs +++ b/src/client/spark/mspark/MarketView/MarketViewVM.cs @@ -115,7 +115,7 @@ namespace mbts.spark public const int Version = 1; public StartupData() { } public StartupData(Security[] securities, SortingCriteria[] sorting_criteria) { - if (securities != null) this.securities = securities.Select(s => s.ToByteArray()).ToArray(); + if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } [ProtoMember(1)] diff --git a/src/client/spark/mspark/Shell/Fills/FillsVM.cs b/src/client/spark/mspark/Shell/Fills/FillsVM.cs index 4187d343f..602ec946b 100644 --- a/src/client/spark/mspark/Shell/Fills/FillsVM.cs +++ b/src/client/spark/mspark/Shell/Fills/FillsVM.cs @@ -128,7 +128,7 @@ namespace mbts.spark public const int Version = 1; public StartupData() { } public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { - if (securities != null) this.securities = securities.Select(s => s.ToByteArray()).ToArray(); + if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } [ProtoMember(1)] diff --git a/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs b/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs index 13147fe37..7f9a7f666 100644 --- a/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs +++ b/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs @@ -32,7 +32,7 @@ namespace mbts.spark while (curr_secmap.Contains(id)) id--; synthetic.Id = id; var sec_strategy = new SyntheticExecutionStrategy { Security = synthetic, ExecutionStrategy = strategy }; - _bus.post(SparkTags.PersistCommandTag, new SparkBusData.PersistMessage(1, "SyntheticSecurity", String.Empty, sec_strategy.ToByteArray())); + _bus.post(SparkTags.PersistCommandTag, new SparkBusData.PersistMessage(1, "SyntheticSecurity", String.Empty, ((IImmutableMessage)sec_strategy).ToByteArray())); } else { // MODIFY } diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs index d5564e1cf..d9744914d 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs @@ -111,7 +111,7 @@ namespace mbts.spark public const int Version = 1; public StartupData() { } public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { - if (securities != null) this.securities = securities.Select(s => s.ToByteArray()).ToArray(); + if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } [ProtoMember(1)] diff --git a/src/client/spark/sys/api/Test/ApiTests.cs b/src/client/spark/sys/api/Test/ApiTests.cs index d7e80b17a..d67fac92d 100644 --- a/src/client/spark/sys/api/Test/ApiTests.cs +++ b/src/client/spark/sys/api/Test/ApiTests.cs @@ -72,7 +72,7 @@ namespace mbts.api.Test { var h = _context.locate(); TableUpdate last_update = null; - using (var sub1 = h.subscribe_greetings().table().Subscribe(t => last_update = t)) { + using (var sub1 = h.subscribe_greetings().Table().Subscribe(t => last_update = t)) { var response = h.say_hello(new HelloRequest() { Name = "UnitTest 1" }); Assert.AreEqual("Hello UnitTest 1", response.Message); diff --git a/src/client/spark/sys/api/Test/HelloServiceServer.cs b/src/client/spark/sys/api/Test/HelloServiceServer.cs index c956fbf9b..d63762126 100644 --- a/src/client/spark/sys/api/Test/HelloServiceServer.cs +++ b/src/client/spark/sys/api/Test/HelloServiceServer.cs @@ -31,10 +31,10 @@ namespace bts.api.core var resp = await _shout.upper_async(new ShoutRequest() { Msg = msg }); // Yell so loud you can't hear the last message _gpub.publish( - added: new List { new HelloLog() { Myid = (++id).ToString(), Message = resp.result.MSG } }, + added: new List { new HelloLog() { Myid = (++id).ToString(), Message = resp.value.MSG } }, removed: new HashSet { (id - 1).ToString() }); switch (resp.success) { - case true: return new HelloResponse() { Message = resp.result.MSG }; + case true: return new HelloResponse() { Message = resp.value.MSG }; default: return new HelloResponse() { Message = "Sorry {0}. We cannot yell at you right now.".fmt(request.Name) }; } } diff --git a/src/client/spark/sys/persist/UISettings.cs b/src/client/spark/sys/persist/UISettings.cs index 564f9940d..242d12a87 100644 --- a/src/client/spark/sys/persist/UISettings.cs +++ b/src/client/spark/sys/persist/UISettings.cs @@ -50,9 +50,9 @@ namespace mbts.persist Ns = uns(ns), Key = { key } }); - check_error(ret.result.Result, ns, key, out bool empty); + check_error(ret.value.Result, ns, key, out bool empty); if (empty) return default(T); - return deserialize(ret.result.Record.Single().Value); + return deserialize(ret.value.Record.Single().Value); } private Google.Protobuf.ByteString serialize(T obj) { @@ -90,9 +90,9 @@ namespace mbts.persist new RetrieveAllRequest() { Ns = uns(ns) }); - check_error(results.result.Result, ns, "", out bool empty); + check_error(results.value.Result, ns, "", out bool empty); if (empty) return Enumerable.Empty>(); - return results.result.Record + return results.value.Record .Where(r => re.IsMatch(r.Key)) .Select(r => new PersistResult() { user = user(), diff --git a/src/client/spark/uicore/Settings/UserPersistFactory.cs b/src/client/spark/uicore/Settings/UserPersistFactory.cs index 31b756a80..1d0504b9e 100644 --- a/src/client/spark/uicore/Settings/UserPersistFactory.cs +++ b/src/client/spark/uicore/Settings/UserPersistFactory.cs @@ -26,7 +26,7 @@ namespace mbts.ui.settings async Task get_users(UserService login) { var users = await login.get_users_async(null); - if (users.success) return users.result.Users.Select(x => x.Login).ToArray(); + if (users.success) return users.value.Users.Select(x => x.Login).ToArray(); else return new string[0]; } diff --git a/src/client/spark/uicore/Shell/Login/LoginModel.cs b/src/client/spark/uicore/Shell/Login/LoginModel.cs index e9101b2eb..04ec1e89a 100644 --- a/src/client/spark/uicore/Shell/Login/LoginModel.cs +++ b/src/client/spark/uicore/Shell/Login/LoginModel.cs @@ -105,7 +105,7 @@ namespace mbts.ui.shell _enum_workspace = new PreloginWorkspaceEnumerator(persist); var response = await _logon.get_users_async(new GetUsersRequest()); if (response.success) { - UserNames = response.result.Users.Select(x => x.Login).ToArray(); + UserNames = response.value.Users.Select(x => x.Login).ToArray(); Array.Sort(UserNames); } else { @@ -127,13 +127,13 @@ namespace mbts.ui.shell Password = password ??"" }); if (response.success) { - if (response.result.IsValid) { + if (response.value.IsValid) { _workspace = workspace; set_authenticated_user(username); return (true, ""); } else { - return (false, response.result.Reason); + return (false, response.value.Reason); } } else { diff --git a/src/client/spark_api/api/Channels/QuickBusClientChannel.cs b/src/client/spark_api/api/Channels/QuickBusClientChannel.cs index 7570d645e..3d777658c 100644 --- a/src/client/spark_api/api/Channels/QuickBusClientChannel.cs +++ b/src/client/spark_api/api/Channels/QuickBusClientChannel.cs @@ -50,18 +50,18 @@ namespace bts.api.core { return tcs.Task; } - public unsafe override IObservable> subscribe(string method_and_qualifier, MessageParser parser) { + public unsafe override IObservable> subscribe(string method_and_qualifier, MessageParser parser, Func converter) { bool first_update = true; - var result = Observable.Create>(observer => { + var result = Observable.Create>(observer => { ApiNativeMethods.raw_subscription_callback cb = (event_type, changes, change_count, unused) => { if (event_type == ApiNativeMethods.EventType.TABLE_UPDATED) { - var added_items = new List(change_count); + var added_items = new List(change_count); var added_keys = new List(change_count); var removed_keys = new List(change_count); foreach (var change in changes) { if (change.type != ApiNativeMethods.ChangeType.REMOVE) { // create or change - added_items.Add(parser.ParseFrom(new UnmanagedMemoryStream(change.buffer, change.buffer_len))); + added_items.Add( converter( parser.ParseFrom(new UnmanagedMemoryStream(change.buffer, change.buffer_len)))); added_keys.Add(change.key); } if (change.type != ApiNativeMethods.ChangeType.CREATE) { @@ -69,11 +69,11 @@ namespace bts.api.core { removed_keys.Add(change.key); } } - observer.OnNext(new RawUpdate(added_items, added_keys, removed_keys)); + observer.OnNext(new RawUpdate(added_items, added_keys, removed_keys)); } else if (event_type == ApiNativeMethods.EventType.TABLE_CREATED) { if (!first_update) { - observer.OnNext(RawUpdate.Reset()); + observer.OnNext(RawUpdate.Reset()); } first_update = false; } diff --git a/src/client/spark_api/api/ClientChannel.cs b/src/client/spark_api/api/ClientChannel.cs index f727f6a0e..003c4ff5a 100644 --- a/src/client/spark_api/api/ClientChannel.cs +++ b/src/client/spark_api/api/ClientChannel.cs @@ -1,21 +1,21 @@ -using Google.Protobuf; -using System; -using System.Threading.Tasks; - -namespace bts.api.core { - internal abstract class ClientChannel : IDisposable +using Google.Protobuf; +using System; +using System.Threading.Tasks; + +namespace bts.api.core { + internal abstract class ClientChannel : IDisposable { readonly ServiceContext _context; public ClientChannel(ServiceContext context) { _context = context; - } - public abstract void Dispose(); - public abstract Task> send(int method_id, Request request) + } + public abstract void Dispose(); + public abstract Task> send(int method_id, Request request) where Request: IImmutableMessage where Response : class,IMessage,new(); - public abstract IObservable> subscribe(string method_and_qualifier, MessageParser parser) - where T : IMessage; - - public abstract bool is_sync_call_ok(); - } -} + public abstract IObservable> subscribe(string method_and_qualifier, MessageParser parser, Func converter=null) + where TParse : IMessage; + + public abstract bool is_sync_call_ok(); + } +} diff --git a/src/client/spark_api/api/Result.cs b/src/client/spark_api/api/Result.cs index 85aae5151..b77386675 100644 --- a/src/client/spark_api/api/Result.cs +++ b/src/client/spark_api/api/Result.cs @@ -3,44 +3,44 @@ using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; - -namespace bts.api.core -{ - - public struct Result - { - public Result(T v) { - _result = v; - _code = ApiError.Success; - } - public Result(ApiError code) { - System.Diagnostics.Debug.Assert(code != ApiError.Success); - _code = code; - _result = default(T); - } - - private string error_string(ApiError code) { - switch (code) { - case ApiError.Success: return "Success"; - case ApiError.NoServer: return "No server found."; - case ApiError.ServerDisconnect: return "Server disconnected."; - case ApiError.MissingMethod: return "Method not found."; - case ApiError.ServerFault: return "Server error."; - default: return "Unknown error"; - } - } - - readonly T _result; - readonly ApiError _code; - - public T result { - get { - if (success) return _result; - else throw new ApiException(error_message); - } - } - public bool success { get { return _code == ApiError.Success; } } - public ApiError code { get { return _code; } } - public string error_message { get { return error_string(_code); } } - } -} + +namespace bts.api.core +{ + + public struct Result + { + public Result(T v) { + _result = v; + _code = ApiError.Success; + } + public Result(ApiError code) { + System.Diagnostics.Debug.Assert(code != ApiError.Success); + _code = code; + _result = default(T); + } + + private string error_string(ApiError code) { + switch (code) { + case ApiError.Success: return "Success"; + case ApiError.NoServer: return "No server found."; + case ApiError.ServerDisconnect: return "Server disconnected."; + case ApiError.MissingMethod: return "Method not found."; + case ApiError.ServerFault: return "Server error."; + default: return "Unknown error"; + } + } + + readonly T _result; + readonly ApiError _code; + + public T value { + get { + if (success) return _result; + else throw new ApiException(error_message); + } + } + public bool success { get { return _code == ApiError.Success; } } + public ApiError code { get { return _code; } } + public string error_message { get { return error_string(_code); } } + } +} diff --git a/src/client/spark_api/api/Update.cs b/src/client/spark_api/api/Update.cs index c704708d2..8342dd17b 100644 --- a/src/client/spark_api/api/Update.cs +++ b/src/client/spark_api/api/Update.cs @@ -1,85 +1,85 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using System.Reactive.Linq; - -namespace bts.api.core { - - public struct RawUpdate { - // RawUpdate uses List instead of IReadonlyList to avoid virtual dispatch on a type not likely to be see in a public api surface - public RawUpdate(List added_items, List added_keys, List removed_keys) : this() { - is_reset = false; - this.added_items = added_items; - this.added_keys = added_keys; - this.removed_keys = removed_keys; - } - - public static RawUpdate Reset() { - return new RawUpdate() { is_reset = true }; - } - +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Reactive.Linq; - public bool is_reset; - public List added_items { get; private set; } - public List added_keys { get; private set; } - public List removed_keys { get; private set; } - } - - public class Update where TKey : IEquatable { - private Func _key; - public Update(IEnumerable all, IReadOnlyList added, IReadOnlyList removed, Func key_extractor) { - this.added = added; - this.removed = removed; - this.all = all; - _key = key_extractor; - } - - public IEnumerable all { get; private set; } - public IReadOnlyList added { get; private set; } - public IReadOnlyList removed { get; private set; } - - public TKey key(T t) { return _key(t); } - } - - public class TableUpdate where TKey : IEquatable { - - readonly Dictionary _state; - readonly IReadOnlyList _added; - readonly IReadOnlyList _removed; - - internal TableUpdate(Dictionary init, IReadOnlyList added, IReadOnlyList removed) { - _state = init; - _added = added; - _removed = removed; - } - - public IReadOnlyDictionary state { get { return _state; } } - public IReadOnlyList added { get { return _added; } } - public IReadOnlyList removed { get { return _removed; } } - - public TableUpdate update(Update update) { - var table = new TableUpdate(new Dictionary(_state), update.added, update.removed); - foreach (var i in update.removed) { - table._state.Remove(update.key(i)); - } - foreach (var item in update.added) { - table._state.Add(update.key(item), item); - } - return table; - } - } - - public static class ObservableUpdateExtensions { - public static IObservable> reconstitute(this IObservable> source, Func key_extractor) where TKey : IEquatable { - var state = new Dictionary(); - return source.Select(raw => { +namespace bts.api.core { + + public struct RawUpdate { + // RawUpdate uses List instead of IReadonlyList to avoid virtual dispatch on a type not likely to be see in a public api surface + public RawUpdate(List added_items, List added_keys, List removed_keys) : this() { + is_reset = false; + this.added_items = added_items; + this.added_keys = added_keys; + this.removed_keys = removed_keys; + } + + public static RawUpdate Reset() { + return new RawUpdate() { is_reset = true }; + } + + + public bool is_reset; + public List added_items { get; private set; } + public List added_keys { get; private set; } + public List removed_keys { get; private set; } + } + + public class Update where TKey : IEquatable { + private Func _key; + public Update(IReadOnlyCollection all, IReadOnlyList added, IReadOnlyList removed, Func key_extractor) { + this.added = added; + this.removed = removed; + this.all = all; + _key = key_extractor; + } + + public IReadOnlyCollection all { get; private set; } + public IReadOnlyList added { get; private set; } + public IReadOnlyList removed { get; private set; } + + public TKey key(T t) { return _key(t); } + } + + public class TableUpdate where TKey : IEquatable { + + readonly Dictionary _state; + readonly IReadOnlyList _added; + readonly IReadOnlyList _removed; + + internal TableUpdate(Dictionary init, IReadOnlyList added, IReadOnlyList removed) { + _state = init; + _added = added; + _removed = removed; + } + + public IReadOnlyDictionary state { get { return _state; } } + public IReadOnlyList added { get { return _added; } } + public IReadOnlyList removed { get { return _removed; } } + + public TableUpdate update(Update update) { + var table = new TableUpdate(new Dictionary(_state), update.added, update.removed); + foreach (var i in update.removed) { + table._state.Remove(update.key(i)); + } + foreach (var item in update.added) { + table._state.Add(update.key(item), item); + } + return table; + } + } + + public static class ObservableUpdateExtensions { + public static IObservable> reconstitute(this IObservable> source, Func key_extractor) where TKey : IEquatable { + var state = new Dictionary(); + return source.Select(raw => { if (raw.is_reset) { var removed = state.Values.ToList(); state.Clear(); return new Update(new T[0], new T[0], removed, key_extractor); - } + } else { var removed = new List(raw.removed_keys.Count); foreach (var r in raw.removed_keys) { @@ -93,14 +93,14 @@ namespace bts.api.core { state[raw.added_keys[x]] = raw.added_items[x]; } return new Update(state.Values, raw.added_items, removed, key_extractor); - } - }); - } - - public static IObservable> table(this IObservable> source) where TKey : IEquatable { - return source.Scan( - new TableUpdate(new Dictionary(), new List(), new List()), - (table, update) => table.update(update)); - } - } -} + } + }); + } + + public static IObservable> Table(this IObservable> source) where TKey : IEquatable { + return source.Scan( + new TableUpdate(new Dictionary(), new List(), new List()), + (table, update) => table.update(update)); + } + } +} diff --git a/src/client/spark_api/utils/IImmutableProto.cs b/src/client/spark_api/utils/IImmutableMessage.cs similarity index 94% rename from src/client/spark_api/utils/IImmutableProto.cs rename to src/client/spark_api/utils/IImmutableMessage.cs index 7764789ec..72d30f57e 100644 --- a/src/client/spark_api/utils/IImmutableProto.cs +++ b/src/client/spark_api/utils/IImmutableMessage.cs @@ -7,7 +7,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace bts { +namespace bts.api { internal interface IImmutableMessage { MessageDescriptor Descriptor { get; } int CalculateSize(); diff --git a/src/lib/api/service_compiler/plugin.py b/src/lib/api/service_compiler/plugin.py index cc6360676..a91288c2a 100755 --- a/src/lib/api/service_compiler/plugin.py +++ b/src/lib/api/service_compiler/plugin.py @@ -77,11 +77,19 @@ EnumModel = namedtuple("EnumModel", "name values") def transform_enum(e): return EnumModel(e.name, []) -MessageModel = namedtuple("MessageModel", "name field nested_type nested_enum") +OneofModel = namedtuple("OneofModel", "name Name") +def transform_oneof(o, msg): + return OneofModel( + name = o.name, + Name = o.name[0].upper() + o.name[1:] + ) + +MessageModel = namedtuple("MessageModel", "name field oneof nested_type nested_enum") def transform_message(i): r = MessageModel( name = i.name, field = [transform_field(f,i) for f in i.field], + oneof = [transform_oneof(o,i) for o in i.oneof_decl], nested_type = [transform_message(m) for m in i.nested_type], nested_enum = [transform_enum(e) for e in i.enum_type], ) @@ -98,12 +106,11 @@ def transform_service(service, keymap): FileModel = namedtuple("FileModel", "name package namespace_csharp message_type service enum_type") def transform_file(p, keymap): - message_types = [transform_message(m) for m in p.message_type] return FileModel( name = p.name, package = p.package, namespace_csharp = p.package, - message_type = message_types, + message_type = [transform_message(m) for m in p.message_type], service = [transform_service(s, keymap) for s in p.service], enum_type = [transform_enum(e) for e in p.enum_type] ) @@ -206,7 +213,6 @@ def generate_insertions(params, request, response): def camel_case(item): if item.isupper() and not '_' in item: return item return item.title().replace('_', '') - return d def generate_code(request, response): diff --git a/src/lib/api/service_compiler/templates/c#/client.pb.cs b/src/lib/api/service_compiler/templates/c#/client.pb.cs index d1af51ae8..3a35cea45 100644 --- a/src/lib/api/service_compiler/templates/c#/client.pb.cs +++ b/src/lib/api/service_compiler/templates/c#/client.pb.cs @@ -20,20 +20,37 @@ public sealed class {{name}} : IApiClient, IDisposable { {{#if server_streaming}} // {{comment}} public IObservable> subscribe_{{name}}({{input_type_full}} qualifier=null) { - return _channel.subscribe<{{output_type_full}}>(ApiServer.format_qualifier("{{name}}",qualifier), {{output_type_full}}.Parser).reconstitute(key); + return _channel.subscribe<{{output_type_full}}, {{output_type_full}}>(ApiServer.format_qualifier("{{name}}",qualifier), {{output_type_full}}.Parser, a=>a).reconstitute(key); + } + internal IObservable> subscribei_{{name}}({{input_type_full}} qualifier=null) { + return _channel.subscribe<{{output_type_full}}, {{output_type_full}}Immutable>(ApiServer.format_qualifier("{{name}}",qualifier), {{output_type_full}}.Parser, a=>({{output_type_full}}Immutable)a).reconstitute(key); } private static {{key_type.cstype}} key({{output_type_full}} row) { return row.{{camel key_field}}; } + private static {{key_type.cstype}} key({{output_type_full}}Immutable row) { + return row.{{camel key_field}}; + } {{else}} // {{comment}} public Task> {{name}}_async({{input_type_full}} request) { return _channel.send<{{input_type_full}},{{output_type_full}}>({{@index}}, request); } + internal Task> {{name}}_async({{input_type_full}}Immutable request) { + return _channel.send<{{input_type_full}}Immutable,{{output_type_full}}>({{@index}}, request); + } // {{comment}} public {{output_type_full}} {{name}}({{input_type_full}} request) { if (_channel.is_sync_call_ok()) { - return {{name}}_async(request).Result.result; + return {{name}}_async(request).Result.value; + } + else { + throw new bts.api.core.ApiException("API blocking call cannot be made on this thread. Please use {{name}}_async instead."); + } + } + internal {{output_type_full}} {{name}}({{input_type_full}}Immutable request) { + if (_channel.is_sync_call_ok()) { + return {{name}}_async(request).Result.value; } else { throw new bts.api.core.ApiException("API blocking call cannot be made on this thread. Please use {{name}}_async instead."); diff --git a/src/lib/api/service_compiler/templates/c#/immutable.pb.cs b/src/lib/api/service_compiler/templates/c#/immutable.pb.cs index 45eb3ca7c..0fdc36732 100644 --- a/src/lib/api/service_compiler/templates/c#/immutable.pb.cs +++ b/src/lib/api/service_compiler/templates/c#/immutable.pb.cs @@ -8,14 +8,14 @@ using Google.Protobuf.WellKnownTypes; namespace {{package}} { {{#each message_type}} - partial class {{name}} : bts.IImmutableMessage { - MessageDescriptor bts.IImmutableMessage.Descriptor => {{name}}.Descriptor; + partial class {{name}} : bts.api.IImmutableMessage { + MessageDescriptor bts.api.IImmutableMessage.Descriptor => {{name}}.Descriptor; } - partial struct {{name}}Immutable : bts.IImmutableMessage { + partial struct {{name}}Immutable : bts.api.IImmutableMessage { readonly {{name}} _impl; public static MessageDescriptor Descriptor => {{name}}.Descriptor; - MessageDescriptor bts.IImmutableMessage.Descriptor => {{name}}.Descriptor; + MessageDescriptor bts.api.IImmutableMessage.Descriptor => {{name}}.Descriptor; public int CalculateSize() => _impl.CalculateSize(); public void WriteTo(CodedOutputStream output) => _impl.WriteTo(output); @@ -42,8 +42,12 @@ namespace {{package}} { public bool Equals({{name}}Immutable other) { return _impl.Equals(other._impl); } + partial void EqualsOverride(ref bool didrun, ref bool result, {{name}}Immutable other); public bool Equals({{name}}Immutable? other) { if (other == null) return false; + bool didrun = false, result = false; + EqualsOverride(ref didrun, ref result, other.Value); + if (didrun) return result; return _impl.Equals(other.Value._impl); } public override int GetHashCode() => _impl.GetHashCode(); @@ -68,6 +72,11 @@ namespace {{package}} { {{/if}} {{/each}} + + // oneof enums + {{#each oneof}} + public {{../name}}.{{Name}}OneofCase {{Name}}Case => _impl.{{Name}}Case; + {{/each}} public {{name}}Immutable with( // Arguments diff --git a/src/lib/sparkproto/SparkProtos.proto b/src/lib/sparkproto/SparkProtos.proto index e4da1bda7..5e4be4e30 100644 --- a/src/lib/sparkproto/SparkProtos.proto +++ b/src/lib/sparkproto/SparkProtos.proto @@ -29,7 +29,7 @@ message Order { } TimeInForce time_in_force = 50; uint64 timestamp = 60; - oneof algo_order_type { + oneof AlgoOrderType { MarketOrder market_order = 100; LimitOrder limit_order = 110; StopMarketOrder stop_market_order = 120; @@ -144,7 +144,7 @@ message BTSShootTillHitOrder /// Only support a limit or market as Retry's /// We can make Retry a general parameter for /// every order - oneof native_order_type + oneof NativeOrderType { MarketOrder market_order = 10; LimitOrder limit_order = 20; @@ -171,7 +171,7 @@ message BTSWithATickParameters message BTSWithATickOrder { BTSWithATickParameters order_parameters = 10; - oneof native_order_type + oneof NativeOrderType { LimitOrder limit_order = 20; } @@ -202,7 +202,7 @@ message BTSTimedWindowParameters message BTSTimedWindowOrder { BTSTimedWindowParameters order_parameters = 10; - oneof native_order_type + oneof NativeOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; @@ -245,12 +245,12 @@ When the market penetrates the trigger price, a limit order is sent "payup" tick message BTSStopOrder { PriceTrigger price_trigger = 10; - oneof native_trigger_order_type + oneof NativeTriggerOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; } - oneof trigger_order_price + oneof TriggerOrderPrice { PriceOffset payup = 40; double price = 50; @@ -269,12 +269,12 @@ Opposite of BTS Stop (Both in terms of where the order is placed, and how it tra message BTSIfTouchedOrder { PriceTrigger price_trigger = 10; - oneof native_trigger_order_type + oneof NativeTriggerOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; } - oneof order_price + oneof OrderPrice { PriceOffset payup = 40; double price = 50; @@ -293,7 +293,7 @@ previous has been filled. message BTSIcebergOrder { QuantityMeasure display_quantity = 10; - oneof child_order_offset + oneof ChildOrderOffset { PriceOffset market_offset = 20; double diff_from_last_fill = 30; @@ -312,7 +312,7 @@ message BTSTimeSliceOrder { double interval = 10; QuantityMeasure display_quantity = 20; - oneof child_order_type + oneof ChildOrderType { MarketOrder market_order = 30; LimitOrder limit_order = 40; @@ -320,7 +320,7 @@ message BTSTimeSliceOrder PriceOffset child_order_offset = 50; /// the earlier order can either be left, or its /// price moved toward the inside market by payup_ticks - oneof left_over_action + oneof LeftOverAction { bool leave = 60; double payup_ticks = 70; @@ -343,12 +343,12 @@ ii. If the stop order is trigerred, the Limit order is cancelled message BTSOCOOrder { PriceTrigger price_trigger = 10; - oneof native_trigger_order_type + oneof NativeTriggerOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; } - oneof order_price + oneof OrderPrice { PriceOffset payup = 40; double price = 50; From cf80d06e07a017a322ef88243aceded961fd23d1 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 10 Nov 2017 12:47:43 -0500 Subject: [PATCH 07/29] Spark-267 --- .../spreader_orders/SpreaderOrder.cpp | 31 --------- .../orderman/spreader_orders/SpreaderOrder.h | 1 - ...SpreaderWaitingForFirstConnStateWorker.cpp | 64 ++++++++++++------- .../SpreaderWaitingForFirstConnStateWorker.h | 13 ++-- src/server/sparkd/spreader/LegPropertyData.h | 2 +- .../sparkd/spreader/SpreaderBookkeepingData.h | 13 +++- 6 files changed, 61 insertions(+), 63 deletions(-) diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index 6fe456f09..be177b970 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -134,37 +134,6 @@ const LegPropertyData& SpreaderOrder::get_leg_data(size_t leg_index) const { return _bookkeeping_data.get_leg_data(leg_index).leg_property_data; } -void SpreaderOrder::_construct_bookkeeping_data_and_quoters() -{ - std::vector leg_data_vector; - //creating the basic data - ISpreaderManager& me_ref = *this; - const bts::api::orderman::CreateSpreaderOrder& cor = _create_order_request.spreader(); - spark::ExecutionStrategy execution_strategy = cor.execution_strategy(); - const bts::api::Security& sec = cor.security(); - size_t leg_idx = 0; - for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) - { - // immutable property data for this leg - const bts::api::ContractLeg& leg = *it; - auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id()); - bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end()); - api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg); - LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side); - // setting up the order for this leg - bts::SecurityKey leg_key = bts::SecurityKey (leg_property_data.security_key()); - api::Security const* db_sec = _db().resolve (leg_key); - bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(*db_sec, leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); - bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory(); - LOG(OrderMan,Diag,"Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), key().value()); - SingleLegQuoter leg_quoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order); - SpreaderLegData leg_data(leg_property_data, leg_quoter, child_order.order_key()); - leg_data_vector.push_back(leg_data); - leg_idx++; - } - bts_assert(leg_data_vector.size() > 0); - _bookkeeping_data = SpreaderBookkeepingData(leg_data_vector); -} void SpreaderOrder::_transform_to_START() { bts_assert (_state_worker == nullptr); diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index 105543b6b..814e399e5 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -73,7 +73,6 @@ public: SpreaderState test_only_func_state (); SpreaderLegData& test_only_func_leg_data (size_t index); private: - void _construct_bookkeeping_data_and_quoters (); void _transform_to_START(); void _transform_to_WAITING_FOR_FIRST_CONNECTION(); void _transform_to_WORKING(); diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp index 66aae2a74..64f8d11e8 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp @@ -15,13 +15,17 @@ void SpreaderWaitingForFirstConnStateWorker::build_once (SpreaderOrder* spreader } void SpreaderWaitingForFirstConnStateWorker::init () { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,init}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::init is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_connect() { + // this is where all the initialization happens. + // if the securities are resolved successfully + // it goes to the working state if (_can_resolve_securities ()) { - _spreader->_construct_bookkeeping_data_and_quoters (); + // this creates the bookkeeping data (which contains the quoters) + _construct_bookkeeping_data_and_quoters (); _init_quoters (); _subscribe_to_marketdata (); _spreader->_transform_to_WORKING (); @@ -29,6 +33,7 @@ void SpreaderWaitingForFirstConnStateWorker::on_connect() else { // if securities can not be resolved, the order is terminated + LOG(OrderMan, Diag, "SpreaderWaitingForFirstConnStateWorker.on_connect key: {} , could not resolve securities", _spreader->key().value()); std::string msg = "Could not resolve securities"; _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg); _spreader->_transform_to_END (); @@ -36,44 +41,42 @@ void SpreaderWaitingForFirstConnStateWorker::on_connect() } void SpreaderWaitingForFirstConnStateWorker::on_disconnect() { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_disconnect}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_disconnect is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update) { _spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity())); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderWaitingForFirstConnStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); _spreader->_transform_to_END(); } void SpreaderWaitingForFirstConnStateWorker::on_book(TickToTradeCorID, Book const&) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_book}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_book is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_time(const TimeStamp&) { } void SpreaderWaitingForFirstConnStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_quoter_order_error}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_quoter_order_error is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_quoter_order_fill}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_quoter_order_fill is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_quoter_order_status_update}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_quoter_order_status_update is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_hedger_order_error}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_hedger_order_error is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_hedger_order_upate}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const&) { @@ -92,15 +95,28 @@ void SpreaderWaitingForFirstConnStateWorker::_init_quoters () } bool SpreaderWaitingForFirstConnStateWorker::_can_resolve_securities () { - const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader(); - const bts::api::Security& sec = cor.security(); + // when the synthetic sec's are truly moved to the server, + // the sec (below) is also resolved (vs getting it directly + // from the CreateSpreaderOrder) + const bts::api::Security& sec = _spreader->_create_order_request.spreader().security(); for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) { const bts::api::ContractLeg& leg = *it; bts::SecurityKey leg_key = bts::SecurityKey (leg.security().id()); - api::Security const* db_sec = _spreader->_db().resolve (leg_key); - if (db_sec == nullptr) + if (leg.security().has_future() || leg.security().has_spread()) + { + api::Security const* db_sec = _spreader->_db().resolve (leg_key); + if (db_sec == nullptr) + { + LOG(OrderMan, Error, "SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker key: {} , could not resolve sec key: {}", _spreader->key().value(), leg_key.value()); + return false; + } + } + else + { + LOG(OrderMan, Error, "SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker key: {} , only futures and future spread legs supported sec key: {}", _spreader->key().value(), leg_key.value()); return false; + } } return true; } @@ -110,7 +126,7 @@ void SpreaderWaitingForFirstConnStateWorker::_subscribe_to_marketdata() { SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(index); bts::SecurityKey leg_key = bts::SecurityKey (leg_data.leg_property_data.security_key()); - api::Security const* db_sec = _spreader->_db().resolve (leg_key); + api::Security const* db_sec = _spreader->_db().resolve (leg_key); _spreader->subscribe_to_md (*db_sec); } } @@ -125,24 +141,26 @@ void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quo size_t leg_idx = 0; for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) { - // immutable property data for this leg + // i. immutable property data for this leg const bts::api::ContractLeg& leg = *it; - auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id()); + uint32_t leg_key = leg.security().id(); + auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg_key); bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end()); api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg); LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side); - // setting up the order for this leg - bts::SecurityKey leg_key = bts::SecurityKey (leg_property_data.security_key()); - api::Security const* db_sec = _spreader->_db().resolve (leg_key); + // ii. setting up the order for this leg + api::Security const* db_sec = _spreader->_db().resolve (bts::SecurityKey (leg_key)); bts::orderman::SpreaderOrderBase::ChildFactory child_factory = _spreader->get_child_factory(*db_sec, leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory(); - LOG(OrderMan,Diag,"Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), _spreader->key().value()); + LOG(OrderMan, Diag, "Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), _spreader->key().value()); + // iii. setting up the quoter (which needs the quoter and property from i and ii) SingleLegQuoter leg_quoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order); + // iv. finally setting up the full leg_data (which needs the quoter and property from i, ii and iii) SpreaderLegData leg_data(leg_property_data, leg_quoter, child_order.order_key()); leg_data_vector.push_back(leg_data); leg_idx++; } bts_assert(leg_data_vector.size() > 0); - _spreader->_bookkeeping_data = SpreaderBookkeepingData(leg_data_vector); + _spreader->_bookkeeping_data = SpreaderBookkeepingData(leg_data_vector, Price(cor.price()), Quantity(cor.quantity())); } }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h index de10ccb1e..291148942 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h @@ -31,12 +31,17 @@ public: void on_external_error(std::string const&) override; void on_check_termination () override; private: - void _init_quoters (); - // calls db.resolve on each leg of the spread - // and makes sure an + // iterates through the spreader leg and verifies + // that every security can be resolved bool _can_resolve_securities (); - void _subscribe_to_marketdata (); + // creates the bookkeeping data and constructs + // the quoters void _construct_bookkeeping_data_and_quoters (); + // calls init on all the quoters + void _init_quoters (); + // iterates through the spreader legs and subs + // to the market data + void _subscribe_to_marketdata (); }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/LegPropertyData.h b/src/server/sparkd/spreader/LegPropertyData.h index dd1c5c816..0f0ac53a8 100644 --- a/src/server/sparkd/spreader/LegPropertyData.h +++ b/src/server/sparkd/spreader/LegPropertyData.h @@ -27,7 +27,7 @@ public: { } uint32_t security_key() const { return leg_contract.security().id(); } // TODO: use seckey - //bts::SecurityKey security_key() const {return bts::SecurityKey (leg_contract.security().id());} + //const bts::SecurityKey& security_key() const {return bts::SecurityKey (leg_contract.security().id());} const bts::api::Security& security() const { return leg_contract.security(); } double price_multiplier() const { return leg_params.price_multiplier(); } double size_multiplier() const { return leg_contract.quantity(); } diff --git a/src/server/sparkd/spreader/SpreaderBookkeepingData.h b/src/server/sparkd/spreader/SpreaderBookkeepingData.h index ec61cf09c..7be548bdc 100644 --- a/src/server/sparkd/spreader/SpreaderBookkeepingData.h +++ b/src/server/sparkd/spreader/SpreaderBookkeepingData.h @@ -17,10 +17,17 @@ private: Price _price; Quantity _quantity; public: - SpreaderBookkeepingData () {} - SpreaderBookkeepingData(const std::vector& leg_data) + SpreaderBookkeepingData () + : _leg_data (std::vector()), + _sec_key_to_index (boost::container::flat_map()), + _price (Price(0)), + _quantity (Quantity(0)) + {} + SpreaderBookkeepingData(const std::vector& leg_data, Price price, Quantity quantity) : - _leg_data (leg_data) + _leg_data (leg_data), + _price (price), + _quantity (quantity) { for (auto it = leg_data.begin(); it != leg_data.end(); ++it) _sec_key_to_index.insert(std::pair(it->leg_property_data.security_key(), it->leg_property_data.leg_index)); From 5998b599be0443d9006b638b8df793efec13cfc4 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 10 Nov 2017 12:59:19 -0500 Subject: [PATCH 08/29] merging --- src/server/sparkd/CMakeDeps.cmake | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/server/sparkd/CMakeDeps.cmake b/src/server/sparkd/CMakeDeps.cmake index f9616bcd8..2a17b4936 100644 --- a/src/server/sparkd/CMakeDeps.cmake +++ b/src/server/sparkd/CMakeDeps.cmake @@ -1 +1 @@ -set(sources ;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/Market.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/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.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/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.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/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp) \ No newline at end of file +set(sources ;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/Market.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/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.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/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.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/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/AccountServiceServer.cpp;user/UserServiceServer.cpp;user/tests/UserAndAccountTests.cpp) \ No newline at end of file From a37483f1464421ea0b25eb7fa5b4aedbdacc6181 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Fri, 10 Nov 2017 13:18:13 -0500 Subject: [PATCH 09/29] Switch shell to use immutable security type --- .../GenericCollectionExtensions.cs | 2 +- src/client/spark/core/bus/IBus.cs | 4 + src/client/spark/core/bus/SingletonBus.cs | 77 ++++++++++--------- .../mspark/Algo/Exchange/GatewayAdapter.cs | 10 +-- .../mspark/Algo/Exchange/IMarketDataSource.cs | 6 +- src/client/spark/mspark/Core/MDSource.cs | 5 +- src/client/spark/mspark/Core/SecurityMD.cs | 7 +- src/client/spark/mspark/Core/SparkBusData.cs | 26 +++---- src/client/spark/mspark/Core/SparkTags.cs | 6 +- .../mspark/Core/SyntheticSecurityMDHandle.cs | 4 +- src/client/spark/mspark/Core/TickUtils.cs | 28 +++---- .../spark/mspark/Ladder/LadderGridHost.cs | 4 +- src/client/spark/mspark/Ladder/LadderModel.cs | 2 +- src/client/spark/mspark/Ladder/LadderVM.cs | 2 +- src/client/spark/mspark/Ladder/LaderRender.cs | 8 +- .../spark/mspark/Ladder/RecenterCountdown.cs | 4 +- .../mspark/MarketView/MarketViewModel.cs | 19 +++-- .../spark/mspark/MarketView/MarketViewRow.cs | 2 +- .../spark/mspark/MarketView/MarketViewVM.cs | 8 +- src/client/spark/mspark/Orders/IOrderBook.cs | 18 ++--- .../spark/mspark/Orders/OrderExtensions.cs | 2 +- .../spark/mspark/Orders/OrderTicketVM.cs | 2 +- .../Orders/Sim/OrderActivitySimulator.cs | 4 +- .../mspark/Orders/Sim/SimExchangeGateway.cs | 6 +- .../SecuritySelectorDialogVM.cs | 4 +- .../SecurityBrowser/SecuritySelectorVM.cs | 16 ++-- .../mspark/SecurityBrowser/SecuritySource.cs | 7 +- .../spark/mspark/Shell/Fills/FillsVM.cs | 16 ++-- .../Shell/LaunchMenu/LaunchMenuItemVM.cs | 6 +- src/client/spark/mspark/Shell/MarketModule.cs | 10 +-- .../Shell/MenuItems/CancelOrdersMenuItem.cs | 4 +- .../spark/mspark/Shell/MenuItems/IMenuItem.cs | 6 +- .../mspark/Shell/MenuItems/LadderMenuItem.cs | 4 +- .../Shell/MenuItems/MarketViewMenuItem.cs | 4 +- .../mspark/Shell/MenuItems/MenuItemVM.cs | 18 ++--- .../ModifySecuritySelectionMenuItem.cs | 6 +- .../Shell/MenuItems/OrderTicketMenuItem.cs | 12 +-- .../Shell/MenuItems/SpreadMatrixMenuItem.cs | 4 +- .../MenuItems/SyntheticCreateMenuItem.cs | 4 +- .../MenuItems/SyntheticStrategyMenuItem.cs | 4 +- .../Shell/MenuItems/TimeAndSalesMenuItem.cs | 6 +- .../mspark/Shell/OrderBook/OrderBookRowVM.cs | 6 +- .../mspark/Shell/OrderBook/OrderBookVM.cs | 2 +- .../Synthetic/SyntheticEditorModel.cs | 3 +- .../Shell/TimeAndSales/TimeAndSalesModel.cs | 14 ++-- .../Shell/TimeAndSales/TimeAndSalesVM.cs | 20 ++--- .../Shell/TimeAndSales/TimeAndSalesWindow.cs | 8 +- src/client/spark/mspark/Shell/TradesModule.cs | 8 +- src/client/spark/mspark/Utilities/BBOVM.cs | 8 +- .../spark/mspark/Utilities/ISecurityMDPump.cs | 15 ++-- .../mspark/Utilities/ImportedResources.cs | 10 +-- .../spark/mspark/Utilities/OrderDataHelper.cs | 6 +- .../mspark/Utilities/SecurityDataHelper.cs | 8 +- .../mspark/Utilities/SyntheticDataHelper.cs | 18 ++--- src/client/spark/sys/api/SecurityConverter.cs | 2 +- .../view/Controls/PriceEntryControl.xaml.cs | 2 +- .../view/Converters/TickDisplayConverter.cs | 4 +- src/client/spark_api/security/Security.cs | 38 ++++++--- .../spark_api/security/SecurityFormatter.cs | 24 +++--- .../spark_api/security/SecurityHelper.cs | 14 ++-- 60 files changed, 311 insertions(+), 286 deletions(-) diff --git a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs index 6f8441e4e..ff184043b 100644 --- a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs +++ b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs @@ -218,7 +218,7 @@ namespace mbts.collections.extensions public static class DictionaryExtensions { #region GetValueOrDefault - public static TValue GetValueOrDefault(this Dictionary dictionary, TKey key) { + public static TValue GetValueOrDefault(this IReadOnlyDictionary dictionary, TKey key) { return dictionary.TryGetValue(key, out TValue result) ? result : default(TValue); } diff --git a/src/client/spark/core/bus/IBus.cs b/src/client/spark/core/bus/IBus.cs index 5983f33f2..2146d24b4 100644 --- a/src/client/spark/core/bus/IBus.cs +++ b/src/client/spark/core/bus/IBus.cs @@ -7,14 +7,18 @@ using System.Threading.Tasks; namespace bts.api { public interface ITag { } + // It is important that ITag is a distinct type from ITag + public interface ITag { } public interface ISubscribe { IObservable subscribe(ITag tag); + IObservable subscribe(ITag tag); } public interface IPost { void post(ITag tag, T data); + void post(ITag tag, T data); } public interface IBus : IPost, ISubscribe diff --git a/src/client/spark/core/bus/SingletonBus.cs b/src/client/spark/core/bus/SingletonBus.cs index 4c37ab31f..fb21dd220 100644 --- a/src/client/spark/core/bus/SingletonBus.cs +++ b/src/client/spark/core/bus/SingletonBus.cs @@ -1,37 +1,44 @@ -using bts.api; +using bts.api; using mbts.utils; -using System; -using System.Collections.Generic; -using System.ComponentModel.Composition; -using System.Reactive.Subjects; - -namespace bts.core -{ - [Export(typeof(IBus))] - public class SingletonBus : IBus { - - private class SubjectSingleton { - public static Dictionary> instance = new Dictionary>(); - } - - private ISubject subject(ITag tag) { - var inst = SubjectSingleton.instance; - lock (inst) { - if (inst.TryGetValue(tag, out ISubject result)) { - return result; - } - result = new StateSubject(); - inst[tag] = result; - return result; - } - } - - public void post(ITag tag, T data) { - subject(tag).OnNext(data); - } - - public IObservable subscribe(ITag tag) { - return subject(tag); - } - } +using System; +using System.Collections.Generic; +using System.ComponentModel.Composition; +using System.Reactive.Subjects; + +namespace bts.core +{ + [Export(typeof(IBus))] + public class SingletonBus : IBus { + + private class SubjectSingleton { + public static Dictionary> instance = new Dictionary>(); + } + + private ISubject subject(object tag) { + var inst = SubjectSingleton.instance; + lock (inst) { + if (inst.TryGetValue(tag, out ISubject result)) { + return result; + } + result = new Subject(); + inst[tag] = result; + return result; + } + } + + public void post(ITag tag, T data) { + subject(tag).OnNext(data); + } + public void post(ITag tag, T data) { + subject(tag).OnNext(data); + } + + public IObservable subscribe(ITag tag) { + return subject(tag); + } + + public IObservable subscribe(ITag tag) { + return subject(tag); + } + } } \ No newline at end of file diff --git a/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs b/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs index 22513e81b..4a7479ce5 100644 --- a/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs +++ b/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs @@ -25,7 +25,7 @@ namespace mbts.spark class GatewayAdapter : IMarketDataSource, IDropCopy, IPollable { SimExchangeGateway _gw; - IDictionary _cache; + IReadOnlyDictionary _cache; object _lock = new object(); ConcurrentBag>> _bbo = new ConcurrentBag>>(); @@ -61,8 +61,8 @@ namespace mbts.spark } } - public IObservable> - subscribe_bbo(bts.api.Security security) + public IObservable> + subscribe_bbo(bts.api.SecurityImmutable security) { lock(_cache) { @@ -77,8 +77,8 @@ namespace mbts.spark } } - public IObservable> - subscribe_depth(bts.api.Security security) + public IObservable> + subscribe_depth(bts.api.SecurityImmutable security) { lock(_cache) { diff --git a/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs b/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs index ce6d89f26..b1c4d010d 100644 --- a/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs +++ b/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs @@ -6,9 +6,9 @@ using mbts.co2; namespace mbts.spark { - public interface IMarketDataSource + interface IMarketDataSource { - IObservable> subscribe_bbo(Security security); - IObservable> subscribe_depth(Security security); + IObservable> subscribe_bbo(SecurityImmutable security); + IObservable> subscribe_depth(SecurityImmutable security); } } \ No newline at end of file diff --git a/src/client/spark/mspark/Core/MDSource.cs b/src/client/spark/mspark/Core/MDSource.cs index 2fe22f22f..9ab5fa1de 100644 --- a/src/client/spark/mspark/Core/MDSource.cs +++ b/src/client/spark/mspark/Core/MDSource.cs @@ -27,7 +27,6 @@ namespace mbts.spark { _bus = bus; _consumer = Co2RelayControl.instance.consumer; - new OrderHub(bus, username); } public void OnCompleted() { } @@ -45,7 +44,6 @@ namespace mbts.spark temp.Add(v.security.Id, new SecurityMD(v.security, v.handle)); } _exchange_sec_map = temp; - //_publish_securities(); } } @@ -83,7 +81,6 @@ namespace mbts.spark if (synth_secs != null && synth_secs.data != null) { _synthetic_sec_map = synth_secs.data.ToDictionaryDupes(s => s.Key, s => new SecurityMD(s.Value.Security, new SyntheticSecurityMDHandle(s.Value.Security, _exchange_sec_map))); - //_publish_securities(); } } @@ -92,7 +89,7 @@ namespace mbts.spark var rv = new Dictionary(_exchange_sec_map); foreach (var kv in _synthetic_sec_map) { - Security sec = kv.Value.security; + var sec = kv.Value.security; rv.Add(sec.Id, new SecurityMD(sec, new SyntheticSecurityMDHandle(sec, _exchange_sec_map))); } Logger.log(bts.log.Level.Info, bts.log.Subsystem.gen, String.Format("MDSource publishing {0} securities", rv.Count)); diff --git a/src/client/spark/mspark/Core/SecurityMD.cs b/src/client/spark/mspark/Core/SecurityMD.cs index 34cc7e004..78295830c 100644 --- a/src/client/spark/mspark/Core/SecurityMD.cs +++ b/src/client/spark/mspark/Core/SecurityMD.cs @@ -1,4 +1,5 @@ -using mbts.co2; +using bts.api; +using mbts.co2; using System; using System.Collections.Generic; using System.Linq; @@ -9,10 +10,10 @@ namespace mbts.spark { struct SecurityMD { - public bts.api.Security security { get; } + public SecurityImmutable security { get; } public IMDHandle md { get; } - public SecurityMD(bts.api.Security security, IMDHandle md) { + public SecurityMD(SecurityImmutable security, IMDHandle md) { this.security = security; this.md = md; } diff --git a/src/client/spark/mspark/Core/SparkBusData.cs b/src/client/spark/mspark/Core/SparkBusData.cs index fcfb650c6..a5b088387 100644 --- a/src/client/spark/mspark/Core/SparkBusData.cs +++ b/src/client/spark/mspark/Core/SparkBusData.cs @@ -50,15 +50,15 @@ namespace mbts.spark } public class ShowAuditLogsMessage { } public class ShowFillsMessage { } - public class ShowLadderMessage : BusMessageWrapper> { - public ShowLadderMessage(Security security) : this(new[] { security }) { } - public ShowLadderMessage(IReadOnlyCollection security) : base(security) { } + public class ShowLadderMessage : BusMessageWrapper> { + public ShowLadderMessage(SecurityImmutable security) : this(new[] { security }) { } + public ShowLadderMessage(IReadOnlyCollection security) : base(security) { } } public class ShowLinkedLadderMessage : BusMessageWrapper> { public ShowLinkedLadderMessage(IObservable security_md) : base(security_md) { } } - public class ShowMarketViewMessage : BusMessageWrapper> { - public ShowMarketViewMessage(IReadOnlyCollection securities) : base(securities) { } + public class ShowMarketViewMessage : BusMessageWrapper> { + public ShowMarketViewMessage(IReadOnlyCollection securities) : base(securities) { } } public class ShowOrderBookMessage { } public class ShowOrderModifyMessage : BusMessageWrapper> { @@ -73,17 +73,17 @@ namespace mbts.spark public ShowLinkedOrderTicketMessage(IObservable order) : base(order) { } } public class ShowPositionsMessage { } - public class ShowSpreadMatrixMessage : BusMessageWrapper> { - public ShowSpreadMatrixMessage(IReadOnlyCollection securities) : base(securities) { } + public class ShowSpreadMatrixMessage : BusMessageWrapper> { + public ShowSpreadMatrixMessage(IReadOnlyCollection securities) : base(securities) { } } - public class ShowSyntheticCreateMessage : BusMessageWrapper> { - public ShowSyntheticCreateMessage(IReadOnlyCollection securities) : base(securities) { } + public class ShowSyntheticCreateMessage : BusMessageWrapper> { + public ShowSyntheticCreateMessage(IReadOnlyCollection securities) : base(securities) { } } - public class ShowSyntheticStrategyMessage : BusMessageWrapper { - public ShowSyntheticStrategyMessage(Security security) : base(security) { } + public class ShowSyntheticStrategyMessage : BusMessageWrapper { + public ShowSyntheticStrategyMessage(SecurityImmutable security) : base(security) { } } - public class ShowTimeAndSalesMessage : BusMessageWrapper> { - public ShowTimeAndSalesMessage(IReadOnlyCollection security) : base(security) { } + public class ShowTimeAndSalesMessage : BusMessageWrapper> { + public ShowTimeAndSalesMessage(IReadOnlyCollection security) : base(security) { } } public class PositionsMessage : BusMessageWrapper> { diff --git a/src/client/spark/mspark/Core/SparkTags.cs b/src/client/spark/mspark/Core/SparkTags.cs index 6e705e902..fa75b6259 100644 --- a/src/client/spark/mspark/Core/SparkTags.cs +++ b/src/client/spark/mspark/Core/SparkTags.cs @@ -1,12 +1,14 @@ using bts.api; +using System.Collections.Generic; namespace mbts.spark { - public static class SparkTags { + static class SparkTags { private class SparkTag : ITag { private readonly string Name; public SparkTag(string name) { Name = name; } } + private class SparkTag : ITag { private readonly string Name; public SparkTag(string name) { Name = name; } } #region Core Data public static ITag ExchangeSecuritiesTag { get; } = new SparkTag("ExchangeSecuritiesTag"); - public static ITag SecuritiesTag { get; } = new SparkTag("Securities"); + public static ITag> SecuritiesTag { get; } = new SparkTag>("Securities"); public static ITag SyntheticSecuritiesTag { get; } = new SparkTag("SyntheticSecuritiesTag"); public static ITag OrderBookTag = new SparkTag("OrderBookTag"); public static ITag PositionsTag { get; } = new SparkTag(nameof(PositionsTag)); diff --git a/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs b/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs index 02258abd6..92a569c65 100644 --- a/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs +++ b/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs @@ -71,10 +71,10 @@ namespace mbts.spark public uint normalized_head_size { get { return active ? levels[0].qty : 0; } } } - private readonly Security _security; + private readonly SecurityImmutable _security; private IEnumerable> _legs; private const uint _default_book_size = 10; - public SyntheticSecurityMDHandle(Security security, IDictionary md_handles) + public SyntheticSecurityMDHandle(SecurityImmutable security, IDictionary md_handles) { _security = security; _legs = security.get_base_exchange_securities().Select(t => diff --git a/src/client/spark/mspark/Core/TickUtils.cs b/src/client/spark/mspark/Core/TickUtils.cs index ce0acbe32..55f58de6a 100644 --- a/src/client/spark/mspark/Core/TickUtils.cs +++ b/src/client/spark/mspark/Core/TickUtils.cs @@ -7,23 +7,23 @@ using System.Collections.ObjectModel; using System.Linq; namespace mbts.spark { - public static class TickUtils { - public static readonly ContractSpecification DefaultSpec = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; - public static double ticksize(this ContractSpecification spec, double price) { + static class TickUtils { + public static readonly ContractSpecificationImmutable DefaultSpec = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; + public static double ticksize(this ContractSpecificationImmutable spec, double price) { return Math.Abs(price) > spec.PriceBreak ? spec.HighTick : spec.LowTick; } - public static string format(this ContractSpecification spec, double price) { + public static string format(this ContractSpecificationImmutable spec, double price) { var tick_factors = _get_tick_factors(spec.ticksize(price)); return tick_factors.format(price, false); } - public static double parse(this ContractSpecification spec, string text) { + public static double parse(this ContractSpecificationImmutable spec, string text) { var regional_tfs = new RegionalTickFactors { low_tick = _get_tick_factors(spec.LowTick), high_tick = _get_tick_factors(spec.HighTick), low_tick_inclusive_end = spec.PriceBreak }; return regional_tfs.parse(text); } - public static double mid_tick(ContractSpecification spec, double bid, double ask) { + public static double mid_tick(ContractSpecificationImmutable spec, double bid, double ask) { double raw_mid; if (double.IsNaN(bid)) { raw_mid = ask; } else if (double.IsNaN(ask)) { raw_mid = bid; } @@ -35,12 +35,12 @@ namespace mbts.spark { } - public static double tickup(this ContractSpecification contract, double value) { return get_regional_ticks(contract).tickup(value); } - public static double tickup(this ContractSpecification contract, double value, int count) { return get_regional_ticks(contract).tickup(value, (uint)count); } - public static double tickdown(this ContractSpecification contract, double value) { return get_regional_ticks(contract).tickdown(value); } - public static double tickdown(this ContractSpecification contract, double value, int count) { return get_regional_ticks(contract).tickdown(value, (uint)count); } + public static double tickup(this ContractSpecificationImmutable contract, double value) { return get_regional_ticks(contract).tickup(value); } + public static double tickup(this ContractSpecificationImmutable contract, double value, int count) { return get_regional_ticks(contract).tickup(value, (uint)count); } + public static double tickdown(this ContractSpecificationImmutable contract, double value) { return get_regional_ticks(contract).tickdown(value); } + public static double tickdown(this ContractSpecificationImmutable contract, double value, int count) { return get_regional_ticks(contract).tickdown(value, (uint)count); } - public static double round_to_tick(this ContractSpecification spec, double value) { + public static double round_to_tick(this ContractSpecificationImmutable spec, double value) { double intpart = (long)value; double floatpart = value % 1; double tick = spec.ticksize(value); @@ -48,7 +48,7 @@ namespace mbts.spark { return intpart + floatpart; } - public static int ticks_between(double a, double b, ContractSpecification spec) { + public static int ticks_between(double a, double b, ContractSpecificationImmutable spec) { double low = Math.Min(a, b); double high = Math.Max(a, b); int count = 0; @@ -59,10 +59,10 @@ namespace mbts.spark { return count; } - public static int[] get_tick_jump_quantities(ContractSpecification spec) { + public static int[] get_tick_jump_quantities(ContractSpecificationImmutable spec) { return _ticks_cache.TryGetValue(spec.LowTick, out (TickFactors tf, int[] jumps) result) ? result.jumps : new[] { 1, 5, 10, 25, 50, 100 }; } - public static RegionalTickFactors get_regional_ticks(ContractSpecification spec) { + public static RegionalTickFactors get_regional_ticks(ContractSpecificationImmutable spec) { return _regional_ticks_cache.GetOrAdd((spec.LowTick, spec.HighTick, spec.PriceBreak), _create_regional_ticks); } private static RegionalTickFactors _create_regional_ticks((double low_tick, double high_tick, double price_break) def) { diff --git a/src/client/spark/mspark/Ladder/LadderGridHost.cs b/src/client/spark/mspark/Ladder/LadderGridHost.cs index a168f6fee..cf481b24e 100644 --- a/src/client/spark/mspark/Ladder/LadderGridHost.cs +++ b/src/client/spark/mspark/Ladder/LadderGridHost.cs @@ -23,7 +23,7 @@ namespace mbts.spark { IDisposable _settings_sub, _tick_sub; LadderSettings _settings; LadderVM _vm; - ContractSpecification _spec; + ContractSpecificationImmutable _spec; VisualHost _visualHost = new VisualHost() {}; LadderOrdersHost _ordershost; @@ -55,7 +55,7 @@ namespace mbts.spark { public event Action click; - public Security security => _vm.security; + public SecurityImmutable security => _vm.security; public ICommand RecenterCommand { get; } public ICommand Command { diff --git a/src/client/spark/mspark/Ladder/LadderModel.cs b/src/client/spark/mspark/Ladder/LadderModel.cs index 3ff7b1cc8..f36504873 100644 --- a/src/client/spark/mspark/Ladder/LadderModel.cs +++ b/src/client/spark/mspark/Ladder/LadderModel.cs @@ -22,7 +22,7 @@ namespace mbts.spark { _order_gateway = ordergw; } - public Security security { get; } + public SecurityImmutable security { get; } public IMDHandle md { get; } public enum CancelType { All, Bids, Asks } diff --git a/src/client/spark/mspark/Ladder/LadderVM.cs b/src/client/spark/mspark/Ladder/LadderVM.cs index 8defb25a0..9d1f15235 100644 --- a/src/client/spark/mspark/Ladder/LadderVM.cs +++ b/src/client/spark/mspark/Ladder/LadderVM.cs @@ -68,7 +68,7 @@ namespace mbts.spark { } internal LadderModel model => _model; - public Security security => _model.security; + public SecurityImmutable security => _model.security; public IMDHandle md => _model.md; public bool is_synthetic => _model.security.ContractCase == Security.ContractOneofCase.Synthetic; diff --git a/src/client/spark/mspark/Ladder/LaderRender.cs b/src/client/spark/mspark/Ladder/LaderRender.cs index ef1bcda38..0c5e07e8a 100644 --- a/src/client/spark/mspark/Ladder/LaderRender.cs +++ b/src/client/spark/mspark/Ladder/LaderRender.cs @@ -30,7 +30,7 @@ namespace mbts.spark { #pragma warning restore CS0618 // Type or member is obsolete } - public static double[] gen_prices(double mid, int row_count, ContractSpecification spec) { + public static double[] gen_prices(double mid, int row_count, ContractSpecificationImmutable spec) { // require odd number Logger.assert(row_count % 2 == 1); var result = new double[row_count]; @@ -48,7 +48,7 @@ namespace mbts.spark { return result; } - public static FormattedText[] format_prices(double[] prices, string font_family, double font_size, SolidColorBrush foreground, ContractSpecification spec) { + public static FormattedText[] format_prices(double[] prices, string font_family, double font_size, SolidColorBrush foreground, ContractSpecificationImmutable spec) { var result = new FormattedText[prices.Length]; var font = new Typeface(font_family); Parallel.For(0, prices.Length, i => { @@ -64,7 +64,7 @@ namespace mbts.spark { } public static double[] render_prices(DrawingVisual price, double mid, int row_count, double row_height, - LadderColumnSettings settings, ContractSpecification spec) { + LadderColumnSettings settings, ContractSpecificationImmutable spec) { var foreground = new SolidColorBrush(settings.foreground.rgb_color()); var background = new SolidColorBrush(settings.background.rgb_color()); var dprices = gen_prices(mid, row_count, spec); @@ -107,7 +107,7 @@ namespace mbts.spark { double[] prices, NativePriceSize[] rungs, double row_height, - ContractSpecification spec, + ContractSpecificationImmutable spec, LadderColumnSettings settings ) { if (rungs.Length > 1) { diff --git a/src/client/spark/mspark/Ladder/RecenterCountdown.cs b/src/client/spark/mspark/Ladder/RecenterCountdown.cs index f4131ec61..a7123afcb 100644 --- a/src/client/spark/mspark/Ladder/RecenterCountdown.cs +++ b/src/client/spark/mspark/Ladder/RecenterCountdown.cs @@ -15,7 +15,7 @@ namespace mbts.spark { DispatcherTimer _timer = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromSeconds(1) }; - Security _security; + SecurityImmutable _security; IMDHandle _handle; LadderSettings _settings; DateTime _last_recenter = DateTime.MaxValue; @@ -29,7 +29,7 @@ namespace mbts.spark { _timer.Start(); } - static (double,double) tick_range(double price, int tick_count, ContractSpecification spec) { + static (double,double) tick_range(double price, int tick_count, ContractSpecificationImmutable spec) { return (TickUtils.tickdown(spec, price, tick_count), TickUtils.tickup(spec, price, tick_count)); } diff --git a/src/client/spark/mspark/MarketView/MarketViewModel.cs b/src/client/spark/mspark/MarketView/MarketViewModel.cs index 1432aa998..6b469bfdc 100644 --- a/src/client/spark/mspark/MarketView/MarketViewModel.cs +++ b/src/client/spark/mspark/MarketView/MarketViewModel.cs @@ -8,8 +8,7 @@ using System.Reactive.Linq; using System.Reactive.Subjects; using static mbts.spark.SparkBusData; using static mbts.spark.SparkTags; -using MDMap = System.Collections.Generic.Dictionary; -using SecurityKey = System.UInt32; +using security_key = System.UInt32; namespace mbts.spark { @@ -25,20 +24,20 @@ namespace mbts.spark private readonly IBus _bus; private readonly OrdersModel _orders_model; - private readonly Subject> _securities_subject = new Subject>(); - private readonly ObservableDemuxer _positions_demuxer = new ObservableDemuxer(k => 0); + private readonly Subject> _securities_subject = new Subject>(); + private readonly ObservableDemuxer _positions_demuxer = new ObservableDemuxer(k => 0); private IList _subs = new List(); - private IDictionary _data = new Dictionary(); + private IDictionary _data = new Dictionary(); - public IObservable> rows => _bus.subscribe(SecuritiesTag).StartWith(new MDMap()).CombineLatest(_securities_subject, (md, secs) => md.Intersect(secs, kv => kv.Key).Select(kv => kv.Value)); - public IReadOnlyCollection all_securities => _data.Values.Select(s => s.security).ToList(); + public IObservable> rows => _bus.subscribe(SecuritiesTag).StartWith(new Dictionary()).CombineLatest(_securities_subject, (md, secs) => md.Intersect(secs, kv => kv.Key).Select(kv => kv.Value)); + public IReadOnlyCollection all_securities => _data.Values.Select(s => s.security).ToList(); public OrdersModel orders_model => _orders_model; - public IObservable security_position(SecurityKey key) { return _positions_demuxer.subscribe(key).DistinctUntilChanged(); } - public void show_ladder(Security security) { _bus.post(ShowLadderTag, new ShowLadderMessage(security)); } + public IObservable security_position(security_key key) { return _positions_demuxer.subscribe(key).DistinctUntilChanged(); } + public void show_ladder(SecurityImmutable security) { _bus.post(ShowLadderTag, new ShowLadderMessage(security)); } public void show_order_modify(Order order) { _bus.post(ShowOrderModifyTag, new ShowOrderModifyMessage(order)); } public void show_order_ticket(Order order) { _orders_model.show_order_ticket(order); } - public void set_securities(IEnumerable securities) { _securities_subject.OnNext(new HashSet(securities.Select(s => s.Id))); } + public void set_securities(IEnumerable securities) { _securities_subject.OnNext(new HashSet(securities.Select(s => s.Id))); } public void Dispose() { Disposable.dispose(_subs); _securities_subject.Dispose(); diff --git a/src/client/spark/mspark/MarketView/MarketViewRow.cs b/src/client/spark/mspark/MarketView/MarketViewRow.cs index a926e0795..12c085dd6 100644 --- a/src/client/spark/mspark/MarketView/MarketViewRow.cs +++ b/src/client/spark/mspark/MarketView/MarketViewRow.cs @@ -80,7 +80,7 @@ namespace mbts.spark private void _animation_AnimationsChanged() { RaisePropertyChanged(nameof(animations)); } #region Bound Properties - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public RXReadOnlyDataGridCell position { get; } public RXReadOnlyDataGridCell last_price { get; } public RXReadOnlyDataGridCell last_size { get; } diff --git a/src/client/spark/mspark/MarketView/MarketViewVM.cs b/src/client/spark/mspark/MarketView/MarketViewVM.cs index 704e6e473..96560bcfd 100644 --- a/src/client/spark/mspark/MarketView/MarketViewVM.cs +++ b/src/client/spark/mspark/MarketView/MarketViewVM.cs @@ -26,7 +26,7 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "MarketView"; - public MarketViewVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + public MarketViewVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { _bus = bus; _resources.Add(_model = new MarketViewModel(bus)); _resources.Add(_rows = new RXObservableCollection(_model.rows)); @@ -80,8 +80,8 @@ namespace mbts.spark } } - private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).DistinctUntilChanged(); } - private static Security _get_security(DataGridCellInfo cell) { return (cell.Item as Row)?.security.value; } + private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).Where(s => s.HasValue).Select(s => s.Value).DistinctUntilChanged(); } + private static SecurityImmutable? _get_security(DataGridCellInfo cell) { return (cell.Item as Row)?.security.value; } private static Order _create_order(DataGridCellInfo cell) { return _create_order((Row)cell.Item, (Columns)DataGridEx.GetArgument(cell.Column)); } private static Order _create_order(Row row, Columns col) { var order = OrderDataHelper.Defaults.Order(row.security.value, Order.AlgoOrderTypeOneofCase.MarketOrder); @@ -114,7 +114,7 @@ namespace mbts.spark public class StartupData { public const int Version = 1; public StartupData() { } - public StartupData(Security[] securities, SortingCriteria[] sorting_criteria) { + public StartupData(SecurityImmutable[] securities, SortingCriteria[] sorting_criteria) { if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } diff --git a/src/client/spark/mspark/Orders/IOrderBook.cs b/src/client/spark/mspark/Orders/IOrderBook.cs index e4fa4fabf..ae479d993 100644 --- a/src/client/spark/mspark/Orders/IOrderBook.cs +++ b/src/client/spark/mspark/Orders/IOrderBook.cs @@ -11,34 +11,34 @@ namespace mbts.spark IEnumerable get_all_orders(); } - public static class OrderBookExtensions + static class OrderBookExtensions { - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, Security security) { return ob.get_all_orders_for_security(security.Id); } - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_orders_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_all_orders_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_orders_for_security(security.Id); } + public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_orders_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_all_orders_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders().Where(e => e.sec_key() == security); } public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_orders_for_security(new HashSet(securities)); } public static IEnumerable get_all_orders_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders().Where(e => securities.Contains(e.sec_key())); } public static IDictionary> get_order_sec_map(this IOrderBook ob) { return ob.get_all_orders().Map(e => e.sec_key()); } public static IEnumerable get_active_orders(this IOrderBook ob) { return ob.get_all_orders().Where(e => e.is_active()); } - public static IEnumerable get_active_orders_for_security(this IOrderBook ob, Security security) { return ob.get_active_orders_for_security(security.Id); } - public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_active_orders_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_active_orders_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_active_orders_for_security(security.Id); } + public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_active_orders_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders().Where(e => e.sec_key() == security && e.is_active()); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_active_orders_for_security(new HashSet(securities)); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders().Where(e => securities.Contains(e.sec_key()) && e.is_active()); } public static IDictionary> get_active_order_sec_map(this IOrderBook ob) { return ob.get_active_orders().Map(e => e.sec_key()); } public static IEnumerable get_all_fills(this IOrderBook ob) { return ob.get_all_orders().SelectMany(e => e.Fills); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, Security security) { return ob.get_all_fills_for_security(security.Id); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fills_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_all_fills_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_fills_for_security(security.Id); } + public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fills_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_all_fills_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders_for_security(security).SelectMany(e => e.Fills); } public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_fills_for_security(new HashSet(securities)); } public static IEnumerable get_all_fills_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders_for_security(securities).SelectMany(e => e.Fills); } public static IDictionary> get_fill_sec_map(this IOrderBook ob) { return ob.get_all_fills().Map(f => f.Order.Security.Id); } public static IEnumerable get_all_fill_tuples(this IOrderBook ob) { return ob.get_all_orders().SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, Security security) { return ob.get_all_fill_tuples_for_security(security.Id); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fill_tuples_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_fill_tuples_for_security(security.Id); } + public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fill_tuples_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders_for_security(security).SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_fill_tuples_for_security(new HashSet(securities)); } public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders_for_security(securities).SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } diff --git a/src/client/spark/mspark/Orders/OrderExtensions.cs b/src/client/spark/mspark/Orders/OrderExtensions.cs index 7e1c5fa05..3d57f06c1 100644 --- a/src/client/spark/mspark/Orders/OrderExtensions.cs +++ b/src/client/spark/mspark/Orders/OrderExtensions.cs @@ -53,7 +53,7 @@ namespace mbts.spark var parts = new List(); if (show_side) parts.Add(order.Side); if (show_security) parts.Add(order.Security.ToString(null)); - if (show_price) parts.Add(order.Security.ContractSpec.format(order.Price)); + if (show_price) parts.Add(((SecurityImmutable)order.Security).ContractSpec.format(order.Price)); if (show_qty) parts.Add("@ {0}".fmt(order.Size)); return string.Join(" ", parts); } diff --git a/src/client/spark/mspark/Orders/OrderTicketVM.cs b/src/client/spark/mspark/Orders/OrderTicketVM.cs index 2f5ad58b2..13fb3d61f 100644 --- a/src/client/spark/mspark/Orders/OrderTicketVM.cs +++ b/src/client/spark/mspark/Orders/OrderTicketVM.cs @@ -19,7 +19,7 @@ namespace mbts.spark return _order; }).Publish(); order_params = new OrderParamsVM(order_pub, model); - bbo = new BBOVM(order.Select(o => o.Security)); + bbo = new BBOVM(order.Select(o => (SecurityImmutable)o.Security)); size_calculator = new CalculatorLogic(0, settings.Select(s => s.calculator_buttons)); set_price_command = new DelegateCommand(p => { price = p; RaisePropertyChanged(nameof(price)); }); send_order = new DelegateCommand(side => { _prepare_order(side); model.send_order(_order); }); diff --git a/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs b/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs index 073b6b11e..9b467ed3f 100644 --- a/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs +++ b/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs @@ -12,14 +12,14 @@ namespace mbts.spark { private readonly OrderHub _hub = null; private readonly IBus _bus = null; - private IDictionary _md_map = new Dictionary(); + private IReadOnlyDictionary _md_map = new Dictionary(); private OrderBook _orderbook = new OrderBook(); public OrderActivitySimulator(OrderHub order_hub, IBus bus) { _hub = order_hub; _bus = bus; - _bus.subscribe>(SparkTags.SecuritiesTag).ObserveOnDispatcher().Subscribe(m => _md_map = m); + _bus.subscribe(SparkTags.SecuritiesTag).ObserveOnDispatcher().Subscribe(m => _md_map = m); _hub.on_new_order += _hub_on_new_order; _hub.on_cancel += _hub_on_order_cancel; _hub.on_price_change += _hub_on_order_price_change; diff --git a/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs b/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs index 4a7a378df..62ea02b20 100644 --- a/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs +++ b/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs @@ -12,7 +12,7 @@ namespace mbts.spark { private readonly IBus _bus; private readonly Venue _venue; - private IDictionary _md_map = new ConcurrentDictionary(); + private IReadOnlyDictionary _md_map = new ConcurrentDictionary(); private IDictionary _worker_map = new ConcurrentDictionary(); public SimExchangeGateway(IBus bus, Venue venue) @@ -88,9 +88,9 @@ namespace mbts.spark internal IObservable on_fills { get { return _fill_sub; } } - internal IObservable> on_md + internal IObservable> on_md { - get { return _bus.subscribe>(SparkTags.SecuritiesTag); } + get { return _bus.subscribe(SparkTags.SecuritiesTag); } } #endregion diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs index e2ac6ee45..bafe55598 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs @@ -8,8 +8,8 @@ namespace mbts.spark { internal class SecuritySelectorDialogVM : SecuritySelectorVM { - public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit) : this (title, preselected_securities, commit, SecuritySource.GetObservable()) { } - public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit, IObservable securities_stream) : base(preselected_securities, securities_stream) { + public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit) : this (title, preselected_securities, commit, SecuritySource.GetObservable()) { } + public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit, IObservable securities_stream) : base(preselected_securities, securities_stream) { this.title = title; this.commit = new DelegateCommand(() => commit(selected_securities)); } diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs index 9462c7058..9e7f04566 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs @@ -7,17 +7,17 @@ using System.Threading; namespace mbts.spark { - public class SecuritySelectorVM : IDisposable + class SecuritySelectorVM : IDisposable { - public SecuritySelectorVM() : this(new Security[0]) { } - public SecuritySelectorVM(IReadOnlyCollection preselected_securities) : this(preselected_securities, SecuritySource.GetObservable()) { } - public SecuritySelectorVM(IReadOnlyCollection preselected_securities, IObservable securities_stream) { - selected_securities = new ObservableCollection(preselected_securities); - securities = new RXObservableCollection(securities_stream, SynchronizationContext.Current, TimeSpan.FromSeconds(1), SecurityHelper.IDEqualityComparer); + public SecuritySelectorVM() : this(new SecurityImmutable[0]) { } + public SecuritySelectorVM(IReadOnlyCollection preselected_securities) : this(preselected_securities, SecuritySource.GetObservable()) { } + public SecuritySelectorVM(IReadOnlyCollection preselected_securities, IObservable securities_stream) { + selected_securities = new ObservableCollection(preselected_securities); + securities = new RXObservableCollection(securities_stream, SynchronizationContext.Current, TimeSpan.FromSeconds(1)); } - public RXObservableCollection securities { get; } - public ObservableCollection selected_securities { get; } + public RXObservableCollection securities { get; } + public ObservableCollection selected_securities { get; } protected virtual void OnDispose() { } public void Dispose() { securities.Dispose(); } diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs index e065364ca..ea162f69e 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs @@ -11,10 +11,11 @@ namespace mbts.spark { internal static class SecuritySource { - public static IObservable GetObservable() { + public static IObservable GetObservable() { return _instance.publisher.AsObservable(); } + // EVIL private static InternalSource _instance; [Export(typeof(IInitializable))] @@ -22,12 +23,12 @@ namespace mbts.spark { [ImportingConstructor] public InternalSource(IBus bus) { - publisher = new StatePublisher(bus.subscribe>(SparkTags.SecuritiesTag) + publisher = new StatePublisher(bus.subscribe(SparkTags.SecuritiesTag) .Select(m => m.Values.Select(s => s.security).Ordered(SecurityDataHelper.Comparer.Instance).ToArray())); _instance = this; } - internal readonly StatePublisher publisher; + internal readonly StatePublisher publisher; public int priority => int.MaxValue; public void initialize() { } diff --git a/src/client/spark/mspark/Shell/Fills/FillsVM.cs b/src/client/spark/mspark/Shell/Fills/FillsVM.cs index 602ec946b..dd39990c8 100644 --- a/src/client/spark/mspark/Shell/Fills/FillsVM.cs +++ b/src/client/spark/mspark/Shell/Fills/FillsVM.cs @@ -24,10 +24,10 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "Fills"; - public FillsVM(IBus bus, OrdersModel model, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { + public FillsVM(IBus bus, OrdersModel model, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { _bus = bus; _model = model; - _securities = new HashSet(securities ?? Enumerable.Empty()); + _securities = new HashSet(securities ?? Enumerable.Empty()); _rows = new ObservableAutoWrapper(_fills, f => new Row(f, _model)); rows_view = CollectionViewSource.GetDefaultView(_rows); if (sorting_criteria != null) rows_view.SortDescriptions.AddRange(sorting_criteria.Select(sc => sc.to_sort_description())); @@ -39,7 +39,7 @@ namespace mbts.spark modify_security_selection = new DialogCommand(() => new SecuritySelectorDialog { DataContext = new SecuritySelectorDialogVM("Fills", _securities.ToArray(), secs => { - _securities = new HashSet(secs); + _securities = new HashSet(secs); _update(); }) }, () => true, true, -12, -30); @@ -49,7 +49,7 @@ namespace mbts.spark private readonly OrdersModel _model; private readonly ObservableCollection _fills = new ObservableCollection(); private readonly ObservableAutoWrapper _rows; - private HashSet _securities; + private HashSet _securities; private IOrderBook _order_book = new OrderBook(); private List _update_log = new List(); private ContextMenuVM _context_menu; @@ -64,7 +64,7 @@ namespace mbts.spark } private IEnumerable _context_menu_item_factory() { var selected_rows = _rows.Where(r => r.is_selected); - var securities = new HashSet(selected_rows.Select(r => r.security.value)); + var securities = new HashSet(selected_rows.Select(r => r.security.value)); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); yield return MenuItemVM.Create(new OrderTicketMenuItem(_model), securities); yield return MenuItemVM.Create(new MarketViewMenuItem(_bus), securities); @@ -92,7 +92,7 @@ namespace mbts.spark _fill = fill.Fill; _entry = fill.OrderBookEntry; _model = model; - security = new SelectableViewModelBase(_fill.Order.Security, SecurityDataHelper.Comparer.Instance); + security = new SelectableViewModelBase(_fill.Order.Security, SecurityDataHelper.Comparer.Instance); uint aggr_fills = 0; foreach (var f in _entry.Fills) if (f.Timestamp <= _fill.Timestamp) aggr_fills += f.Size; order_percentage = (double)aggr_fills / (double)_fill.Order.Size; @@ -109,7 +109,7 @@ namespace mbts.spark public string account => _fill.Order.Account; public string user => _fill.Order.User; public Venue exchange => _fill.Order.Security.Exchange; - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public Side side => _fill.Order.Side; public double price => _fill.Price; public uint size => _fill.Size; @@ -127,7 +127,7 @@ namespace mbts.spark public class StartupData { public const int Version = 1; public StartupData() { } - public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { + public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } diff --git a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs index 7a01bdd09..69b7fb964 100644 --- a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs +++ b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs @@ -68,9 +68,9 @@ namespace mbts.spark.menu_items { internal SecurityLaunchMenuItem(string display_name, string sectional_id, ImageSource icon, ICommand launch_command, Template template_key, IDisposable dispose) : base(display_name, sectional_id, icon, template_key:template_key, dispose:dispose) { this.launch_command = launch_command; } - private RXObservableCollection _securities = new RXObservableCollection(SecuritySource.GetObservable()); - public RXObservableCollection securities => _securities; - public ObservableCollection selected_securities { get; } = new ObservableCollection(); + private RXObservableCollection _securities = new RXObservableCollection(SecuritySource.GetObservable()); + public RXObservableCollection securities => _securities; + public ObservableCollection selected_securities { get; } = new ObservableCollection(); public ICommand launch_command { get; } protected override void Dispose(bool disposing) { Disposable.dispose(ref _securities); } } diff --git a/src/client/spark/mspark/Shell/MarketModule.cs b/src/client/spark/mspark/Shell/MarketModule.cs index 9f315d05e..cd75859ba 100644 --- a/src/client/spark/mspark/Shell/MarketModule.cs +++ b/src/client/spark/mspark/Shell/MarketModule.cs @@ -27,7 +27,7 @@ namespace mbts.spark _bus = bus; _wm = wm; _dispose = Disposable.Create( - _bus.subscribe>(SecuritiesTag).ObserveOnDispatcher().Subscribe(s => _securities = s), + _bus.subscribe(SecuritiesTag).ObserveOnDispatcher().Subscribe(s => _securities = s), _bus.subscribe(SyntheticSecuritiesTag).ObserveOnDispatcher().Subscribe(ssm => _synthetic_strategy_map = ssm.data), _bus.subscribe(ShowMarketViewTag).ObserveOnDispatcher().Subscribe(show_market_view), _bus.subscribe(ShowSpreadMatrixTag).ObserveOnDispatcher().Subscribe(show_spread_matrix), @@ -43,7 +43,7 @@ namespace mbts.spark private readonly IBus _bus; private readonly IWindowManager _wm; private readonly IDisposable _dispose; - private IDictionary _securities = new Dictionary(); + private IReadOnlyDictionary _securities = new Dictionary(); private IDictionary _synthetic_strategy_map = new Dictionary(); public int priority => 2; @@ -68,7 +68,7 @@ namespace mbts.spark if (_securities != null && _securities.TryGetValue((uint)header.version, out SecurityMD md)) return create_ladder_window(md); else break; case MarketViewVM.SAVE_NAME: - if (try_deserialize(load_stream, out MarketViewVM.StartupData data)) return create_market_view(data.securities.Select(deserialize).ToList(), data.sorting_criteria); + if (try_deserialize(load_stream, out MarketViewVM.StartupData data)) return create_market_view(data.securities.Select(deserialize).Cast().ToList(), data.sorting_criteria); else break; } } @@ -83,7 +83,7 @@ namespace mbts.spark #region MarketView private void show_market_view(ShowMarketViewMessage msg) { _wm.Windows.Add(create_market_view(msg.data, null)); } - private IShellWindow create_market_view(IReadOnlyCollection securities, IReadOnlyCollection sorting) { + private IShellWindow create_market_view(IReadOnlyCollection securities, IReadOnlyCollection sorting) { var vm = new MarketViewVM(_bus, securities, sorting); var view = new MarketViewView { DataContext = vm }; const double two_thirds = 2.0 / 3.0; @@ -170,7 +170,7 @@ namespace mbts.spark string warn_msg = $"Did not find execution strategy for {msg.data}"; Logger.warn(bts.log.Subsystem.Ui, warn_msg); show_synthetic_editor_warning(warn_msg); - } else show_synthetic_editor(msg.data, ses.ExecutionStrategy); + } else show_synthetic_editor(msg.data.CloneToMutable(), ses.ExecutionStrategy); } private void show_synthetic_editor_warning(string warn_msg) { BTSMessageBox.Show(warn_msg, "Synthetic Strategy", MessageBoxButton.OK, MessageBoxImage.Exclamation, true, false, true); diff --git a/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs index 3feab29ab..59bc0bae9 100644 --- a/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs @@ -22,11 +22,11 @@ namespace mbts.spark.menu_items public int priority => 0; public ImageSource icon => Icons.CancelOrders; public string sectional_id => MenuItemSections.OrderOp; - public void execute(IReadOnlyCollection securities) { + public void execute(IReadOnlyCollection securities) { var orders = _orderbook.get_all_orders().Select(e => e.order()).Where(o => securities.Contains(o.Security) && filter(o)).Select(o => o.Id).ToList(); _model.cancel_order(orders); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs index 79c785a8e..d8f10f860 100644 --- a/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs @@ -25,10 +25,10 @@ namespace mbts.spark.menu_items bool can_execute(); } - public interface IMenuSecuritiesActionItem : IMenuItem, ICanExecuteChanged + interface IMenuSecuritiesActionItem : IMenuItem, ICanExecuteChanged { - void execute(IReadOnlyCollection securities); - bool can_execute(IReadOnlyCollection securities); + void execute(IReadOnlyCollection securities); + bool can_execute(IReadOnlyCollection securities); } public interface IMenuGroupItem : IMenuItem diff --git a/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs index 4ad04ec54..00d035135 100644 --- a/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs @@ -20,8 +20,8 @@ namespace mbts.spark.menu_items public int priority => 2; public ImageSource icon => Icons.Depth; public string sectional_id => MenuItemSections.OrderActiveWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(ShowLadderTag, new ShowLadderMessage(securities)); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } + public void execute(IReadOnlyCollection securities) { _bus.post(ShowLadderTag, new ShowLadderMessage(securities)); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs index 616f1a78f..fd5e6a20c 100644 --- a/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs @@ -19,8 +19,8 @@ namespace mbts.spark.menu_items public int priority => 0; public ImageSource icon => Icons.Sheets; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowMarketViewTag, new SparkBusData.ShowMarketViewMessage(securities.ToList())); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } + public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowMarketViewTag, new SparkBusData.ShowMarketViewMessage(securities.ToList())); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs b/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs index 0c61523e6..d8846029c 100644 --- a/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs +++ b/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs @@ -15,18 +15,18 @@ using System.Windows.Media; namespace mbts.spark.menu_items { - public class MenuItemVM : DisposableViewModelBase + class MenuItemVM : DisposableViewModelBase { #region Static Factory - public static IList CreateMenu(ObservableCollection selected_securities, params IMenuItem[] menu_items) { + public static IList CreateMenu(ObservableCollection selected_securities, params IMenuItem[] menu_items) { return menu_items.Select(m => Create(m, selected_securities)).ToList(); } - public static IList CreateMenu(IReadOnlyCollection selected_securities, params IMenuItem[] menu_items) { + public static IList CreateMenu(IReadOnlyCollection selected_securities, params IMenuItem[] menu_items) { return menu_items.Select(m => Create(m, selected_securities)).ToList(); } - public static MenuItemVM Create(IMenuItem model, ObservableCollection selected_securities) { + public static MenuItemVM Create(IMenuItem model, ObservableCollection selected_securities) { var act_mi = model as IMenuActionItem; if (act_mi != null) return Create(act_mi); var secs_mi = model as IMenuSecuritiesActionItem; @@ -36,7 +36,7 @@ namespace mbts.spark.menu_items throw new NotImplementedException("LaunchMenuVM cannot create vm for {0} ({1}).".fmt(model?.display_name ?? "unnamed", model?.GetType().ToString() ?? "null")); } - public static MenuItemVM Create(IMenuItem model, IReadOnlyCollection selected_securities) { + public static MenuItemVM Create(IMenuItem model, IReadOnlyCollection selected_securities) { var act_mi = model as IMenuActionItem; if (act_mi != null) return Create(act_mi); var secs_mi = model as IMenuSecuritiesActionItem; @@ -50,21 +50,21 @@ namespace mbts.spark.menu_items return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, _hook_command(model, model.execute, model.can_execute), dispose: model as IDisposable); } - public static MenuItemVM Create(IMenuSecuritiesActionItem model, IReadOnlyCollection selected_securities) { + public static MenuItemVM Create(IMenuSecuritiesActionItem model, IReadOnlyCollection selected_securities) { return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, _hook_command(model, () => model.execute(selected_securities), () => model.can_execute(selected_securities))); } - public static MenuItemVM Create(IMenuSecuritiesActionItem model, ObservableCollection selected_securities) { + public static MenuItemVM Create(IMenuSecuritiesActionItem model, ObservableCollection selected_securities) { var command = _hook_command(model, () => model.execute(selected_securities), () => model.can_execute(selected_securities)); IDisposable sub = selected_securities.Subscribe((s, e) => command.RaiseCanExecuteChanged()); return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, command, dispose: Disposable.Create(() => { (model as IDisposable)?.Dispose(); sub?.Dispose(); })); } - public static MenuItemVM Create(IMenuGroupItem model, ObservableCollection selected_securities) { + public static MenuItemVM Create(IMenuGroupItem model, ObservableCollection selected_securities) { return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, new DelegateCommand(() => { }, () => model.items.Any()), CreateMenu(selected_securities, model.items.ToArray())); } - public static MenuItemVM Create(IMenuGroupItem model, IReadOnlyCollection selected_securities) { + public static MenuItemVM Create(IMenuGroupItem model, IReadOnlyCollection selected_securities) { return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, new DelegateCommand(() => { }, () => model.items.Any()), CreateMenu(selected_securities, model.items.ToArray())); } diff --git a/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs index 43e97e1c4..00c424c39 100644 --- a/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs @@ -9,14 +9,14 @@ namespace mbts.spark.menu_items { internal class ModifySecuritySelectionMenuItem : IMenuActionItem { - public ModifySecuritySelectionMenuItem(IReadOnlyCollection securities, Action> commit, string dialog_title="Select Securities") { + public ModifySecuritySelectionMenuItem(IReadOnlyCollection securities, Action> commit, string dialog_title="Select Securities") { _securities = securities; _commit = commit; _dialog_title = dialog_title; } private readonly string _dialog_title; - private readonly IReadOnlyCollection _securities; - private readonly Action> _commit; + private readonly IReadOnlyCollection _securities; + private readonly Action> _commit; public string display_name => "Add/Remove Securities"; public int priority => int.MinValue; public ImageSource icon => Icons.Coins; diff --git a/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs index a4bc181bd..88e6e2a49 100644 --- a/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs @@ -13,20 +13,20 @@ namespace mbts.spark.menu_items { internal class OrderTicketMenuItem : IMenuSecuritiesActionItem { - public OrderTicketMenuItem(OrdersModel model, Func order_factory=null) { + public OrderTicketMenuItem(OrdersModel model, Func order_factory=null) { _model = model; - _order_factory = order_factory ?? new Func(s => new Order { Security = s, LimitOrder = new LimitOrder(), Size = 1 }); + _order_factory = order_factory ?? new Func(s => new Order { Security = s.CloneToMutable(), LimitOrder = new LimitOrder(), Size = 1 }); } private readonly OrdersModel _model; - private readonly Func _order_factory; + private readonly Func _order_factory; public string display_name => "Order Ticket"; public int priority => 3; public ImageSource icon => Icons.Ticket; public string sectional_id => MenuItemSections.OrderActiveWindow; - public void execute(IReadOnlyCollection securities) { _model.show_order_ticket(securities.Select(_order_factory).ToList()); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } + public void execute(IReadOnlyCollection securities) { _model.show_order_ticket(securities.Select(_order_factory).ToList()); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; @@ -35,7 +35,7 @@ namespace mbts.spark.menu_items internal class LinkedOrderTicketMenuItem : IMenuActionItem { - public LinkedOrderTicketMenuItem(IBus bus, IObservable security, Func order_factory) : this(bus, security.Select(order_factory).Where(o => o != null)) { } + public LinkedOrderTicketMenuItem(IBus bus, IObservable security, Func order_factory) : this(bus, security.Select(order_factory).Where(o => o != null)) { } public LinkedOrderTicketMenuItem(IBus bus, IObservable order) { _bus = bus; _order = order; diff --git a/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs index d16a43673..0af9e2d2a 100644 --- a/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs @@ -19,8 +19,8 @@ namespace mbts.spark.menu_items public int priority => 1; public ImageSource icon => Icons.Cube3d; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowSpreadMatrixTag, new SparkBusData.ShowSpreadMatrixMessage(securities.ToList())); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } + public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowSpreadMatrixTag, new SparkBusData.ShowSpreadMatrixMessage(securities.ToList())); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs index 9e52eabec..398e34d9d 100644 --- a/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs @@ -22,8 +22,8 @@ namespace mbts.spark.menu_items public int priority => 2; public ImageSource icon => Icons.Tetris; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticCreateTag, new ShowSyntheticCreateMessage(securities)); } - public bool can_execute(IReadOnlyCollection securities) { + public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticCreateTag, new ShowSyntheticCreateMessage(securities)); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 1 || (securities.Count == 1 && (securities.First().ContractCase == ContractOneofCase.Synthetic || securities.First().ContractCase == ContractOneofCase.Spread)); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } diff --git a/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs index 5380e078a..26acf54ed 100644 --- a/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs @@ -21,8 +21,8 @@ namespace mbts.spark.menu_items public int priority => 1; public ImageSource icon => Icons.Knight; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticStrategyTag, new ShowSyntheticStrategyMessage(securities.First())); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Count == 1 && securities.First().ContractCase == Security.ContractOneofCase.Synthetic; } + public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticStrategyTag, new ShowSyntheticStrategyMessage(securities.First())); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count == 1 && securities.First().ContractCase == Security.ContractOneofCase.Synthetic; } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs index c19acea3f..25bbd6ff3 100644 --- a/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs @@ -7,7 +7,7 @@ using System.Windows.Media; namespace mbts.spark.menu_items { - public class TimeAndSalesMenuItem : IMenuSecuritiesActionItem + class TimeAndSalesMenuItem : IMenuSecuritiesActionItem { public TimeAndSalesMenuItem(IBus bus) { _bus = bus; @@ -19,8 +19,8 @@ namespace mbts.spark.menu_items public int priority => 4; public ImageSource icon => Icons.Clock; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection ordered_selection) { _bus.post(SparkTags.ShowTimeAndSalesTag, new SparkBusData.ShowTimeAndSalesMessage(ordered_selection.ToList())); } - public bool can_execute(IReadOnlyCollection ordered_selection) { return ordered_selection.Any(); } + public void execute(IReadOnlyCollection ordered_selection) { _bus.post(SparkTags.ShowTimeAndSalesTag, new SparkBusData.ShowTimeAndSalesMessage(ordered_selection.ToList())); } + public bool can_execute(IReadOnlyCollection ordered_selection) { return ordered_selection.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs b/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs index 823378dcb..8af4a9111 100644 --- a/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs +++ b/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs @@ -17,7 +17,7 @@ namespace mbts.spark _parent = parent; _model = model; _order = entry; - security = new SelectableViewModelBase(_order.order().Security, SecurityDataHelper.Comparer.Instance); + security = new SelectableViewModelBase(_order.order().Security, SecurityDataHelper.Comparer.Instance); _visible = backing(nameof(is_visible), !is_child); _expanded = backing(nameof(is_expanded), false); details_command = new DelegateCommand(() => _model.show_order_details(order_id)); @@ -37,7 +37,7 @@ namespace mbts.spark // the grid view uses this for sorting, it was just a bts.api.Security once upon a time, but that class no longer implements IComparable // this SelectableViewModeBase is essentially a wrapper class, which implements ISelecatble and IComparable - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public OrderBookEntry order => _order; public string security_text { // indent child 3 spaces @@ -114,7 +114,7 @@ namespace mbts.spark public double average_price { get => _order.Fills.Count > 0 ? - _order.order().Security.ContractSpec.round_to_tick( + ((SecurityImmutable)_order.order().Security).ContractSpec.round_to_tick( _order.Fills.Sum(f => f.Price * f.Size) / _order.Fills.Sum(f => f.Size)) : 0; set => ignore(); diff --git a/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs b/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs index ccaf82668..da9afb041 100644 --- a/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs +++ b/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs @@ -80,7 +80,7 @@ namespace mbts.spark { private IEnumerable _context_menu_item_factory() { var selected_rows = this.orders.Where(vm => vm.is_selected && vm.is_visible).ToList(); var orders = selected_rows.Select(vm => vm.order).ToList(); - var securities = new HashSet(selected_rows.Select(vm => vm.security.value)); + var securities = new HashSet(selected_rows.Select(vm => vm.security.value)); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); yield return MenuItemVM.Create(new OrderTicketMenuItem(_model), securities); yield return MenuItemVM.Create(new MarketViewMenuItem(_bus), securities); diff --git a/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs b/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs index 7f9a7f666..fc8d977f6 100644 --- a/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs +++ b/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs @@ -4,7 +4,6 @@ using Google.Protobuf; using System; using System.Collections.Generic; using System.Reactive.Linq; -using MDMap = System.Collections.Generic.Dictionary; namespace mbts.spark { @@ -24,7 +23,7 @@ namespace mbts.spark /// The new strategy to create, or existing strategy modify public async void save(Security synthetic, ExecutionStrategy strategy) { if (synthetic.ContractCase != Security.ContractOneofCase.Synthetic) throw new ArgumentException("Must be a synthetic security.", nameof(synthetic)); - var map = await _bus.subscribe(SparkTags.SecuritiesTag).FirstAsync(); + var map = await _bus.subscribe(SparkTags.SecuritiesTag).FirstAsync(); if (synthetic.Id == 0) { // CREATE var curr_secmap = new HashSet(map.Keys); diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs index 2636793c1..b7af9bf12 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs @@ -12,7 +12,7 @@ namespace mbts.spark { internal class TimeAndSalesModel : IDisposable { - public TimeAndSalesModel(IBus bus, IReadOnlyCollection securities) { + public TimeAndSalesModel(IBus bus, IReadOnlyCollection securities) { set_securities(securities); _orders_model = new OrdersModel(bus); _work_loop = WorkLoop.Start(_refresh); @@ -21,25 +21,25 @@ namespace mbts.spark private readonly IDisposable _work_loop; private readonly OrdersModel _orders_model; - private readonly Subject>> _trades = new Subject>>(); - private readonly Dictionary _channels = new Dictionary(); + private readonly Subject>> _trades = new Subject>>(); + private readonly Dictionary _channels = new Dictionary(); private void _refresh() { var ts = _channels.SelectMany(kv => kv.Value.read_trades().Select(t => Tuple.Create(kv.Key, t))).ToList(); if (ts.Count > 0) _trades.OnNext(ts); } - private static IEnumerable _get_real_securities(Security security) { + private static IEnumerable _get_real_securities(SecurityImmutable security) { if (security.ContractCase == Security.ContractOneofCase.Synthetic) foreach (var s in security.Synthetic.Legs.Select(l => l.Security).SelectMany(_get_real_securities)) yield return s; else yield return security; } - public IObservable>> trades => _trades.AsObservable(); - public IReadOnlyCollection securities => _channels.Keys; + public IObservable>> trades => _trades.AsObservable(); + public IReadOnlyCollection securities => _channels.Keys; public OrdersModel orders_model => _orders_model; - public void set_securities(IEnumerable securities) { + public void set_securities(IEnumerable securities) { var real_secs = securities.SelectMany(_get_real_securities); foreach (var r in _channels.Keys.Except(real_secs).ToList()) _channels.Remove(r); foreach (var a in real_secs.Except(_channels.Keys).ToList()) { diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs index d9744914d..f7967fea5 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs @@ -26,10 +26,10 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "TimeAndSales"; - public TimeAndSalesVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { + public TimeAndSalesVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { _bus = bus; _resources.Add(_model = new TimeAndSalesModel(bus, securities)); - _rows = new ObservableAutoWrapper>(_trades, tup => new Row(tup.Item1, tup.Item2)); + _rows = new ObservableAutoWrapper>(_trades, tup => new Row(tup.Item1, tup.Item2)); _rows.ViewDestroyed += r => r.Dispose(); _resources.Add(Disposable.Create(() => _rows.Clear())); rows_view = CollectionViewSource.GetDefaultView(_rows); @@ -53,15 +53,15 @@ namespace mbts.spark private readonly IBus _bus; private readonly TimeAndSalesModel _model; - private readonly ObservableCollection> _trades = new ObservableCollection>(); - private readonly ObservableAutoWrapper> _rows; + private readonly ObservableCollection> _trades = new ObservableCollection>(); + private readonly ObservableAutoWrapper> _rows; private readonly ContextMenuVM _context_menu; private readonly ColdObseravbleProperty _current_cell = new ColdObseravbleProperty(); private IList _resources = new List(); private IOrderBook _order_book = new OrderBook(); private IEnumerable _context_menu_item_factory() { - yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(new HashSet(_rows.Select(r => r.security.value)), _model.set_securities)); + yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(new HashSet(_rows.Select(r => r.security.value)), _model.set_securities)); if (current_cell != null && current_cell.Column != null && current_cell.Item != null && !current_cell.Item.Equals(System.Windows.DependencyProperty.UnsetValue)) { var securities = _rows.Where(r => r.is_selected).Select(r => r.security.value).ToList(); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); @@ -80,8 +80,8 @@ namespace mbts.spark } } - private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).DistinctUntilChanged(); } - private static Security _get_security(DataGridCellInfo cell) { return ((Row)cell.Item).security.value; } + private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).DistinctUntilChanged(); } + private static SecurityImmutable _get_security(DataGridCellInfo cell) { return ((Row)cell.Item).security.value; } public ICollectionView rows_view { get; private set; } public DataGridCellInfo current_cell { get => _current_cell.Value; set => _current_cell.set(value); } @@ -91,7 +91,7 @@ namespace mbts.spark public void Dispose() { Disposable.dispose(_resources); } private class Row : GridRowViewModelBase { - public Row(Security security, TradeMessage trade) { + public Row(SecurityImmutable security, TradeMessage trade) { this.security = AddCell(Columns.Security, security, SecurityDataHelper.Comparer.Instance); quantity = AddCell(Columns.Size, trade.Size); price = AddCell(Columns.Price, trade.Mantissa * Math.Pow(10, trade.Exponent)); @@ -99,7 +99,7 @@ namespace mbts.spark order_type = AddCell(Columns.OrderType, Order.AlgoOrderTypeOneofCase.None); } - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public SelectableViewModelBase quantity { get; } public SelectableViewModelBase price { get; } public SelectableViewModelBase trade_time { get; } @@ -110,7 +110,7 @@ namespace mbts.spark public class StartupData { public const int Version = 1; public StartupData() { } - public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { + public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs index 0cedfcb20..103d59f7f 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs @@ -12,10 +12,10 @@ namespace mbts.spark { internal class TimeAndSalesWindow : IShellWindow { - public TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities) : this (owner, bus, securities, null) { } - public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data) : this(owner, bus, startup_data.securities.Select(deserialize).ToList(), startup_data.sorting_criteria) { } + public TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities) : this (owner, bus, securities, null) { } + public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data) : this(owner, bus, startup_data.securities.Select(deserialize).Cast().ToList(), startup_data.sorting_criteria) { } - private TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + private TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { _bus = bus; _securities = securities; _sorting_criteria = sorting_criteria; @@ -23,7 +23,7 @@ namespace mbts.spark } private readonly IBus _bus; - private readonly IReadOnlyCollection _securities; + private readonly IReadOnlyCollection _securities; private readonly IReadOnlyCollection _sorting_criteria; private TimeAndSalesVM _vm; private IShellModule _owner; diff --git a/src/client/spark/mspark/Shell/TradesModule.cs b/src/client/spark/mspark/Shell/TradesModule.cs index ab7de6249..41aa7152d 100644 --- a/src/client/spark/mspark/Shell/TradesModule.cs +++ b/src/client/spark/mspark/Shell/TradesModule.cs @@ -68,16 +68,16 @@ namespace mbts.spark return ShellWindow.create(this, "Order Book", view, vm.get_state); } - private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(deserialize).ToList(), startup_data.sorting_criteria); } - private IShellWindow create_fills_window(IReadOnlyCollection securities) { return create_fills_window(securities, null); } - private IShellWindow create_fills_window(IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(deserialize).Cast().ToList(), startup_data.sorting_criteria); } + private IShellWindow create_fills_window(IReadOnlyCollection securities) { return create_fills_window(securities, null); } + private IShellWindow create_fills_window(IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { var vm = new FillsVM(_bus, new OrdersModel(_bus), securities, sorting_criteria); var view = new FillsView { DataContext = vm, Width = 1024, Height = 800 }; return ShellWindow.create(this, "Fills", view, vm.get_state, Icons.Ticket); } private void show_order_book(ShowOrderBookMessage msg) { _wm.Windows.Add(create_order_book_window(new OrderBookState())); } - private void show_fills(ShowFillsMessage msg) { _wm.Windows.Add(create_fills_window(new List())); } + private void show_fills(ShowFillsMessage msg) { _wm.Windows.Add(create_fills_window(new List())); } private void show_audit_log(ShowAuditLogsMessage msg) { } private void show_positions(ShowPositionsMessage msg) { } private void show_time_and_sales(ShowTimeAndSalesMessage msg) { _wm.Windows.Add(new TimeAndSalesWindow(this, _bus, msg.data)); } diff --git a/src/client/spark/mspark/Utilities/BBOVM.cs b/src/client/spark/mspark/Utilities/BBOVM.cs index 4d85c8691..385483f36 100644 --- a/src/client/spark/mspark/Utilities/BBOVM.cs +++ b/src/client/spark/mspark/Utilities/BBOVM.cs @@ -10,8 +10,8 @@ namespace mbts.spark { public BBOVM(uint security) : this(Observable.Return(security)) { } public BBOVM(IObservable security) : this(security.ToSecurity()) { } - public BBOVM(IObservable security) : this(security, new SecurityMDPump(security)) { } - public BBOVM(IObservable security, ISecurityMDPump md_pump) { + public BBOVM(IObservable security) : this(security, new SecurityMDPump(security)) { } + public BBOVM(IObservable security, ISecurityMDPump md_pump) { _security = backing(nameof(security), security, Security.Empty); _bid = backing(nameof(bid), md_pump.bid_price, double.NaN); _ask = backing(nameof(ask), md_pump.ask_price, double.NaN); @@ -19,11 +19,11 @@ namespace mbts.spark _ask_size = backing(nameof(ask_size), md_pump.ask_size, (ushort)0); } - private readonly Property _security; + private readonly Property _security; private readonly Property _bid, _ask; private readonly Property _bid_size, _ask_size; - public Security security => _security.Value; + public SecurityImmutable security => _security.Value; public double bid => _bid.Value; public double ask => _ask.Value; public ushort bid_size => _bid_size.Value; diff --git a/src/client/spark/mspark/Utilities/ISecurityMDPump.cs b/src/client/spark/mspark/Utilities/ISecurityMDPump.cs index 1044c2893..e81bcb669 100644 --- a/src/client/spark/mspark/Utilities/ISecurityMDPump.cs +++ b/src/client/spark/mspark/Utilities/ISecurityMDPump.cs @@ -6,7 +6,6 @@ using System.Collections.Generic; using System.Linq; using System.Reactive.Linq; using System.Reactive.Subjects; -using MDMap = System.Collections.Generic.Dictionary; namespace mbts.spark.utilities { @@ -28,18 +27,18 @@ namespace mbts.spark.utilities internal class SecurityMDPump : ISecurityMDPump, IDisposable { - public SecurityMDPump(Security security) : this(security, WorkLoop.DefaultPollInterval) { } - public SecurityMDPump(Security security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } - public SecurityMDPump(Security security, IObservable poll) : this(security.Id, poll) { } - public SecurityMDPump(IObservable security) : this(security.Select(s => s.Id)) { } - public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security.Select(s => s.Id), poll_interval) { } - public SecurityMDPump(IObservable security, IObservable poll) : this(security.Select(s => s.Id), poll) { } + public SecurityMDPump(SecurityImmutable security) : this(security, WorkLoop.DefaultPollInterval) { } + public SecurityMDPump(SecurityImmutable security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } + public SecurityMDPump(SecurityImmutable security, IObservable poll) : this(security.Id, poll) { } + public SecurityMDPump(IObservable security) : this(security.Select(s => s.Id)) { } + public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security.Select(s => s.Id), poll_interval) { } + public SecurityMDPump(IObservable security, IObservable poll) : this(security.Select(s => s.Id), poll) { } public SecurityMDPump(uint security) : this(security, WorkLoop.DefaultPollInterval) { } public SecurityMDPump(uint security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } public SecurityMDPump(uint security, IObservable poll) : this(Observable.Return(security).ToSecurity(), poll) { } public SecurityMDPump(IObservable security) : this(security, WorkLoop.DefaultPollInterval) { } public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } - public SecurityMDPump(IObservable security, IObservable poll) : this(security.CombineLatest(ImportedResources.Bus.subscribe(SparkTags.SecuritiesTag), (s, m) => m.GetValueOrDefault(s).md).Where(md => md != null), poll) { } + public SecurityMDPump(IObservable security, IObservable poll) : this(security.CombineLatest(ImportedResources.Bus.subscribe(SparkTags.SecuritiesTag), (s, m) => m.GetValueOrDefault(s).md).Where(md => md != null), poll) { } public SecurityMDPump(IMDHandle md) : this(Observable.Return(md)) { } public SecurityMDPump(IMDHandle md, TimeSpan poll_interval) : this(Observable.Return(md), poll_interval) { } public SecurityMDPump(IMDHandle md, IObservable poll) : this(Observable.Return(md), poll) { } diff --git a/src/client/spark/mspark/Utilities/ImportedResources.cs b/src/client/spark/mspark/Utilities/ImportedResources.cs index c6df8bb03..9b5272e51 100644 --- a/src/client/spark/mspark/Utilities/ImportedResources.cs +++ b/src/client/spark/mspark/Utilities/ImportedResources.cs @@ -16,14 +16,14 @@ namespace mbts.spark.utilities public static readonly string[] Accounts = new[] { "Account1", "Account2", "Account3", "Account4" }; #region Misc Extensions (should put these in a more appropriate place eventually) - public static IObservable ToSecurity(this IObservable securityKey) { - return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk).security).Where(s => s != null); + public static IObservable ToSecurity(this IObservable securityKey) { + return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk).security); } public static IObservable ToSecurityMD(this IObservable securityKey) { - return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk)); + return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk)); } - public static IObservable ToSecurityMD(this IObservable security) { - return security.CombineLatest(Bus.subscribe(SecuritiesTag), (s, map) => map.GetValueOrDefault(s.Id)); + public static IObservable ToSecurityMD(this IObservable security) { + return security.CombineLatest(Bus.subscribe(SecuritiesTag), (s, map) => map.GetValueOrDefault(s.Id)); } #endregion diff --git a/src/client/spark/mspark/Utilities/OrderDataHelper.cs b/src/client/spark/mspark/Utilities/OrderDataHelper.cs index 493907091..29e5aa50b 100644 --- a/src/client/spark/mspark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/mspark/Utilities/OrderDataHelper.cs @@ -39,12 +39,12 @@ namespace mbts.spark.utilities BTSIcebergOrder }; - public static Order Order(Security security) { return Order(security, bts.spark.Order.AlgoOrderTypeOneofCase.LimitOrder); } - public static Order Order(Security security, Order.AlgoOrderTypeOneofCase algo_type) { + public static Order Order(SecurityImmutable security) { return Order(security, bts.spark.Order.AlgoOrderTypeOneofCase.LimitOrder); } + public static Order Order(SecurityImmutable security, Order.AlgoOrderTypeOneofCase algo_type) { var rv = new Order { Account = ImportedResources.Accounts.FirstOrDefault(), User = ImportedResources.UserName, - Security = security, + Security = security.CloneToMutable(), }; switch (algo_type) { case bts.spark.Order.AlgoOrderTypeOneofCase.LimitOrder: rv.LimitOrder = new LimitOrder(); break; diff --git a/src/client/spark/mspark/Utilities/SecurityDataHelper.cs b/src/client/spark/mspark/Utilities/SecurityDataHelper.cs index 7b351eba8..3119c69cf 100644 --- a/src/client/spark/mspark/Utilities/SecurityDataHelper.cs +++ b/src/client/spark/mspark/Utilities/SecurityDataHelper.cs @@ -6,13 +6,13 @@ using static bts.api.Security; namespace mbts.spark { - public static class SecurityDataHelper + static class SecurityDataHelper { public static class Comparer { - public static readonly IComparer Instance = Comparer.Create(Compare); + public static readonly IComparer Instance = Comparer.Create(Compare); - public static int Compare(Security x, Security y) { + public static int Compare(SecurityImmutable x, SecurityImmutable y) { if (x == null) return y == null ? 0 : -1; if (y == null) return 1; if (x.ContractCase == ContractOneofCase.Future) return y.ContractCase == ContractOneofCase.Future ? Compare(x.Symbol, x.Future, y.Symbol, y.Future) : -1; @@ -35,7 +35,7 @@ namespace mbts.spark return xlegs.Length.CompareTo(ylegs.Length); } - public static int Compare(string x_sym, FutureContract x, string y_sym, FutureContract y) { + public static int Compare(string x_sym, FutureContractImmutable x, string y_sym, FutureContractImmutable y) { int sym_comp = x_sym.CompareTo(y_sym); return sym_comp == 0 ? x.RawExpDate().CompareTo(y.RawExpDate()) : sym_comp; } diff --git a/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs b/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs index c4bfb6513..68a9d3c3a 100644 --- a/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs +++ b/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs @@ -130,16 +130,16 @@ namespace mbts.spark.utilities public static PostHedgeTimeBasedForcedCross PostHedgeTimeBasedForcedCross => new PostHedgeTimeBasedForcedCross(); #endregion - public static Security Security(string name, Security from) { + public static Security Security(string name, SecurityImmutable from) { Security rv = null; switch(from.ContractCase) { case bts.api.Security.ContractOneofCase.Spread: - var legs = from.Spread.Legs.ToList(); - rv = from.Clone(); + var legs = from.Spread.Legs.Select(l => l.CloneToMutable()).ToList(); + rv = from.CloneToMutable(); rv.Synthetic = SyntheticContract(name, legs); break; case bts.api.Security.ContractOneofCase.Synthetic: - rv = from.Clone(); + rv = from.CloneToMutable(); rv.Synthetic.Name = name; break; default: throw new ArgumentException("Must be a Synthetic, or Spread.", nameof(from)); @@ -147,7 +147,7 @@ namespace mbts.spark.utilities rv.Id = 0; return rv; } - public static Security Security(string name, IEnumerable securities) { return Security(name, securities.Select(ContractLeg), MathUtils.GCD(securities.Select(s => s.ContractSpec.LowTick))); } + public static Security Security(string name, IEnumerable securities) { return Security(name, securities.Select(ContractLeg), MathUtils.GCD(securities.Select(s => s.ContractSpec.LowTick))); } public static Security Security(string name, IEnumerable legs, double tick_size) { return new Security { Id = 0, @@ -166,18 +166,18 @@ namespace mbts.spark.utilities foreach (var l in legs) rv.Legs.Add(l); return rv; } - public static ContractLeg ContractLeg(Security security) { - return new ContractLeg { Security = security, PriceMultiplier = 1, Quantity = 1, Side = Side.Buy }; + public static ContractLeg ContractLeg(SecurityImmutable security) { + return new ContractLeg { Security = security.CloneToMutable(), PriceMultiplier = 1, Quantity = 1, Side = Side.Buy }; } - public static ExecutionStrategy ExecutionStrategy(Security security) { + public static ExecutionStrategy ExecutionStrategy(SecurityImmutable security) { switch(security.ContractCase) { case bts.api.Security.ContractOneofCase.Spread: return ExecutionStrategy(security.Spread.Legs.Select(l => l.Security)); case bts.api.Security.ContractOneofCase.Synthetic: return ExecutionStrategy(security.Synthetic.Legs.Select(l => l.Security)); default: throw new ArgumentException("Must be a Spread, or Synthetic", nameof(security)); } } - public static ExecutionStrategy ExecutionStrategy(IEnumerable securities) { return ExecutionStrategy(securities.Select(s => s.Id)); } + public static ExecutionStrategy ExecutionStrategy(IEnumerable securities) { return ExecutionStrategy(securities.Select(s => s.Id)); } public static ExecutionStrategy ExecutionStrategy(IEnumerable security_keys) { var rv = new ExecutionStrategy(); foreach (var sk in security_keys) rv.LegParamsMap.Add(sk, LegSpreaderParams); diff --git a/src/client/spark/sys/api/SecurityConverter.cs b/src/client/spark/sys/api/SecurityConverter.cs index 861a913e5..9904a3b7d 100644 --- a/src/client/spark/sys/api/SecurityConverter.cs +++ b/src/client/spark/sys/api/SecurityConverter.cs @@ -4,7 +4,7 @@ namespace bts.api { static class SecurityConverter { - public static SecurityType security_type(this Security security) { + public static SecurityType security_type(this SecurityImmutable security) { switch (security.ContractCase) { case ContractOneofCase.Future: return SecurityType.Future; case ContractOneofCase.Spread: return SecurityType.Spread; diff --git a/src/client/spark/view/Controls/PriceEntryControl.xaml.cs b/src/client/spark/view/Controls/PriceEntryControl.xaml.cs index 11ab946c8..29a5ca5f9 100644 --- a/src/client/spark/view/Controls/PriceEntryControl.xaml.cs +++ b/src/client/spark/view/Controls/PriceEntryControl.xaml.cs @@ -38,7 +38,7 @@ namespace mbts.ui.spark #region ContractSpec public static readonly DependencyProperty ContractSpecProperty = DependencyProperty.Register("ContractSpec", typeof(ContractSpecification), typeof(PriceEntryControl), new PropertyMetadata(TickUtils.DefaultSpec, OnContractSpecChanged)); private static void OnContractSpecChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ((PriceEntryControl)d)._update_text_binding(); } - public ContractSpecification ContractSpec { get => GetValue(ContractSpecProperty) as ContractSpecification; set => SetValue(ContractSpecProperty, value); } + public ContractSpecificationImmutable ContractSpec { get => GetValue(ContractSpecProperty) as ContractSpecification; set => SetValue(ContractSpecProperty, value); } #endregion public PriceEntryControl() { diff --git a/src/client/spark/view/Converters/TickDisplayConverter.cs b/src/client/spark/view/Converters/TickDisplayConverter.cs index 7f7a05aa1..1a3deb4b1 100644 --- a/src/client/spark/view/Converters/TickDisplayConverter.cs +++ b/src/client/spark/view/Converters/TickDisplayConverter.cs @@ -13,7 +13,7 @@ namespace mbts.ui.spark.converters public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { var price = (double)values[0]; if (HideNaN && double.IsNaN(price)) return string.Empty; - var spec = (ContractSpecification)values[1]; + var spec = (ContractSpecificationImmutable)values[1]; return spec.format(price); } @@ -25,7 +25,7 @@ namespace mbts.ui.spark.converters internal class TickDisplayTwoWayConverter : IValueConverter { public bool HideNaN { get; set; } - public ContractSpecification ContractSpec { get; set; } = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; + public ContractSpecificationImmutable ContractSpec { get; set; } = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { var price = (double)value; diff --git a/src/client/spark_api/security/Security.cs b/src/client/spark_api/security/Security.cs index 6af51346c..04c517a40 100644 --- a/src/client/spark_api/security/Security.cs +++ b/src/client/spark_api/security/Security.cs @@ -4,11 +4,12 @@ using System.Collections.Generic; using System.Linq; using static bts.api.SecurityFormatter; using static bts.api.Security; +using security_key = System.UInt32; namespace bts.api { public partial class Security : IFormattable { - private static readonly PartFormattingTuple[] _standard_format = new[] { + internal static readonly PartFormattingTuple[] _standard_format = new[] { new PartFormattingTuple(ContractParts.Name, "!"), new PartFormattingTuple(ContractParts.Quantity), new PartFormattingTuple(ContractParts.Symbol, "."), @@ -19,34 +20,49 @@ namespace bts.api { return Format(this, string.IsNullOrEmpty(format) ? _standard_format : Parse(format)); } + internal static readonly Security Empty = new Security { + Exchange = Venue.Bts, + ContractSpec = new ContractSpecification { CashPerPoint = double.NaN, HighTick = double.NaN, LowTick = double.NaN, PriceBreak = double.NaN, PriceMultiplier = double.NaN } + }; + + public static security_key key(Security s) { return s.Id; } + } + + partial struct SecurityImmutable : IComparable { + public int CompareTo(SecurityImmutable other) { + return Id.CompareTo(other.Id); + } + public string ToString(string format, IFormatProvider formatProvider=null) { + return Format(this, string.IsNullOrEmpty(format) ? _standard_format : Parse(format)); + } + + partial void EqualsOverride(ref bool didrun, ref bool result, SecurityImmutable other) { + didrun = true; + result = Id == other.Id; + } + /// /// Traverses the security to get the leaf /// exchange securities /// /// - public IEnumerable> get_base_exchange_securities () + internal IEnumerable> get_base_exchange_securities () { List> rv = new List> (); get_base_exchange_securities (this, Side.Buy, 1.0, ref rv); return rv; } - - private static void get_base_exchange_securities (Security sec, Side side, double mult, ref List> legs) + private static void get_base_exchange_securities (SecurityImmutable sec, Side side, double mult, ref List> legs) { Func resolve_side = (s1, s2) => ((s1 == Side.Buy ? 1 : -1) * (s2 == Side.Buy ? 1 : -1)) == 1 ? Side.Buy : Side.Sell; if (sec.ContractCase == ContractOneofCase.Future) legs.Add (Tuple.Create (sec.Id, side, mult)); else if (sec.ContractCase == ContractOneofCase.Spread) - foreach (ContractLeg leg in sec.Spread.Legs) + foreach (ContractLegImmutable leg in sec.Spread.Legs) get_base_exchange_securities (leg.Security, resolve_side (side, leg.Side), leg.Quantity * mult, ref legs); else if (sec.ContractCase == ContractOneofCase.Synthetic) - foreach (ContractLeg leg in sec.Synthetic.Legs) + foreach (ContractLegImmutable leg in sec.Synthetic.Legs) get_base_exchange_securities (leg.Security, resolve_side (side, leg.Side), leg.Quantity * mult, ref legs); } - - public static readonly Security Empty = new Security { - Exchange = Venue.Bts, - ContractSpec = new ContractSpecification { CashPerPoint = double.NaN, HighTick = double.NaN, LowTick = double.NaN, PriceBreak = double.NaN, PriceMultiplier = double.NaN } - }; } } \ No newline at end of file diff --git a/src/client/spark_api/security/SecurityFormatter.cs b/src/client/spark_api/security/SecurityFormatter.cs index fb5a501de..1b028bc15 100644 --- a/src/client/spark_api/security/SecurityFormatter.cs +++ b/src/client/spark_api/security/SecurityFormatter.cs @@ -2,7 +2,7 @@ using System; using System.Collections.Generic; using System.Linq; -using FutureLeg = System.Tuple; +using FutureLeg = System.Tuple; namespace bts.api { @@ -16,7 +16,7 @@ namespace bts.api }).ToList(); } - public static string Format(Security s, IEnumerable parts) { + public static string Format(SecurityImmutable s, IEnumerable parts) { var part_formatters = parts.Select(p => PartFormatterFactory.get_formatter(p)).ToList(); switch(s.ContractCase) { case Security.ContractOneofCase.Future: return _format_future(s, part_formatters); @@ -52,11 +52,11 @@ namespace bts.api } } - private static string _format_future(Security s, IEnumerable part_formatters) { return _format(s, part_formatters, _add_future); } + private static string _format_future(SecurityImmutable s, IEnumerable part_formatters) { return _format(s, part_formatters, _add_future); } private static string _format_future_leg(FutureLeg l, IEnumerable part_formatters) { return _format(l, part_formatters, _add_future_leg); } private delegate bool AddPart(T t, IPartFormatter part_formatter, out string result); - private static bool _add_future(Security s, IPartFormatter part_formatter, out string result) { return part_formatter.add_part(s, out result); } + private static bool _add_future(SecurityImmutable s, IPartFormatter part_formatter, out string result) { return part_formatter.add_part(s, out result); } private static bool _add_future_leg(FutureLeg l, IPartFormatter part_formatter, out string result) { return part_formatter.add_part(l, out result); } private static string _format(T t, IEnumerable part_formatters, AddPart add_part) { @@ -77,7 +77,7 @@ namespace bts.api { string separator { get; } bool add_part(FutureLeg fl, out string result); - bool add_part(Security s, out string result); + bool add_part(SecurityImmutable s, out string result); } private static class PartFormatterFactory @@ -122,7 +122,7 @@ namespace bts.api result = null; return false; } - public bool add_part(Security s, out string result) { + public bool add_part(SecurityImmutable s, out string result) { if (s.ContractCase == Security.ContractOneofCase.Synthetic) { result = s.Synthetic.Name; return true; @@ -150,7 +150,7 @@ namespace bts.api } return true; } - public bool add_part(Security s, out string result) { + public bool add_part(SecurityImmutable s, out string result) { result = null; return false; } @@ -161,24 +161,24 @@ namespace bts.api } public string separator { get; } public bool add_part(FutureLeg fl, out string result) { result = fl.Item2; return true; } - public bool add_part(Security s, out string result) { result = s.Symbol; return true; } + public bool add_part(SecurityImmutable s, out string result) { result = s.Symbol; return true; } } private class Formatter : IPartFormatter { - public Formatter(Func get_sec_value, Func get_leg_value, string separator) : this(get_sec_value, get_leg_value, t => t.ToString(), separator) { } - public Formatter(Func get_sec_value, Func get_leg_value, Func format, string separator) { + public Formatter(Func get_sec_value, Func get_leg_value, string separator) : this(get_sec_value, get_leg_value, t => t.ToString(), separator) { } + public Formatter(Func get_sec_value, Func get_leg_value, Func format, string separator) { _get_sec_value = get_sec_value; _get_leg_value = get_leg_value; _format = format; _separator = separator; } - private readonly Func _get_sec_value; + private readonly Func _get_sec_value; private readonly Func _get_leg_value; private readonly Func _format; private readonly string _separator; private T _last_val; public string separator => _separator ?? string.Empty; - public bool add_part(Security s, out string result) { + public bool add_part(SecurityImmutable s, out string result) { T val = _get_sec_value(s); if (!val.Equals(_last_val)) { result = _format(_last_val = val); diff --git a/src/client/spark_api/security/SecurityHelper.cs b/src/client/spark_api/security/SecurityHelper.cs index b20796afc..8b874c083 100644 --- a/src/client/spark_api/security/SecurityHelper.cs +++ b/src/client/spark_api/security/SecurityHelper.cs @@ -3,14 +3,14 @@ using System; using System.Collections.Generic; using System.Linq; using static bts.api.Security; -using FutureLeg = System.Tuple; +using FutureLeg = System.Tuple; namespace bts.api { internal static class SecurityHelper { #region Private Members - private static IEnumerable _get_flat_future_legs(RepeatedField legs, int qty) { + private static IEnumerable _get_flat_future_legs(IEnumerable legs, int qty) { foreach (var l in legs) { switch (l.Security.ContractCase) { case ContractOneofCase.Future: yield return new FutureLeg(l.Security.Exchange, l.Security.Symbol, l.Security.Future, qty * l.SignedQuantity()); break; @@ -26,7 +26,7 @@ namespace bts.api } #endregion - public static IEnumerable get_flat_future_legs(Security sec) { + public static IEnumerable get_flat_future_legs(SecurityImmutable sec) { switch (sec.ContractCase) { case ContractOneofCase.Spread: return _get_flat_future_legs(sec.Spread.Legs, 1); case ContractOneofCase.Synthetic: return _get_flat_future_legs(sec.Synthetic.Legs, 1); @@ -37,16 +37,16 @@ namespace bts.api public static readonly IEqualityComparer IDEqualityComparer = new InternalIDEqualityComparer(); #region Extensions - public static DateTime RawExpDate(this FutureContract future) { return new DateTime((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay); } + public static DateTime RawExpDate(this FutureContractImmutable future) { return new DateTime((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay); } // TODO: Remove (probably do not need MappedExpDates in spark) - public static DateTime MappedExpDate(this FutureContract future) { + internal static DateTime MappedExpDate(this FutureContractImmutable future) { return RawExpDate(future); } - public static int SignedQuantity(this ContractLeg leg) { return leg.Side == Side.Buy ? (int)leg.Quantity : -(int)leg.Quantity; } + internal static int SignedQuantity(this ContractLegImmutable leg) { return leg.Side == Side.Buy ? (int)leg.Quantity : -(int)leg.Quantity; } - public static string ForceSymbol(this Security security) { + internal static string ForceSymbol(this Security security) { if (security.ContractCase == ContractOneofCase.Synthetic) return ForceSymbol(security.Synthetic.Legs.First().Security); else return security.Symbol; } From 4b4eed91f0eae3d3cdbf8265cc61a6cb6dbc611a Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Fri, 10 Nov 2017 14:02:20 -0500 Subject: [PATCH 10/29] Fix stringly typed oneof in OrderTypeVM --- src/client/spark/mspark/Ladder/OrderTypeVM.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/client/spark/mspark/Ladder/OrderTypeVM.cs b/src/client/spark/mspark/Ladder/OrderTypeVM.cs index 14cba9453..fc41a32e2 100644 --- a/src/client/spark/mspark/Ladder/OrderTypeVM.cs +++ b/src/client/spark/mspark/Ladder/OrderTypeVM.cs @@ -23,7 +23,7 @@ namespace mbts.spark { is_bts_type = order.Descriptor.Name.StartsWith("BTS", StringComparison.CurrentCultureIgnoreCase); algo_type = OrderDataHelper.get_algo_type(order); _accessor = Order.Descriptor.Oneofs - .First(ood => ood.Name == "algo_order_type") + .First(ood => ood.Name == "AlgoOrderType") .Fields .First(f => f.MessageType == order.Descriptor) .Accessor; From 1eee21118f4c8f3c2e47c1795af0b6c0f4c49c13 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Fri, 10 Nov 2017 16:14:57 -0500 Subject: [PATCH 11/29] Enable override port for unison and ssh in buildsparkd.cmd/runsparkd.cmd - SPARKVM_PORT and SPARKVM_UNISON_PORT --- tools/buildsparkd.cmd | 4 +++- tools/replicator/replicate_to_linux_vm.py | 4 +++- tools/runsparkd.cmd | 3 ++- 3 files changed, 8 insertions(+), 3 deletions(-) diff --git a/tools/buildsparkd.cmd b/tools/buildsparkd.cmd index 6d4654e7d..018ce6adb 100644 --- a/tools/buildsparkd.cmd +++ b/tools/buildsparkd.cmd @@ -1,4 +1,6 @@ @echo off +@setlocal +if "%SPARKVM_PORT%"=="" set SPARKVM_PORT=22 python %~dp0\replicator\replicate_to_linux_vm.py echo. -ssh bts@sparkvm -p 22 -o StrictHostKeyChecking=no "cd /home/bts/spark/build/ninja_debug/ && ninja" +ssh bts@sparkvm -p %SPARKVM_PORT% -o StrictHostKeyChecking=no "cd /home/bts/spark/build/ninja_debug/ && ninja" diff --git a/tools/replicator/replicate_to_linux_vm.py b/tools/replicator/replicate_to_linux_vm.py index 44bb2f380..a2667bd67 100644 --- a/tools/replicator/replicate_to_linux_vm.py +++ b/tools/replicator/replicate_to_linux_vm.py @@ -4,7 +4,7 @@ import os, sys, subprocess, time spark_profile = \ '''\ root = $SOURCE -root = socket://sparkvm:8080/$TARGET +root = socket://sparkvm:$PORT/$TARGET ignore = Path build ignore = Path .git ignore = Path externals @@ -29,6 +29,8 @@ repo_name = os.path.basename(repo_root) profile_loc = os.path.join(os.path.abspath(os.environ['USERPROFILE']),'.unison') spark_profile = spark_profile.replace("$SOURCE", repo_root) spark_profile = spark_profile.replace("$TARGET", repo_name) +spark_profile = spark_profile.replace("$PORT", os.getenv("SPARKVM_UNISON_PORT", "8080")) + unison_exe = os.path.join(repo_root,"externals","windows","bin","unison.exe") diff --git a/tools/runsparkd.cmd b/tools/runsparkd.cmd index 16e8bd050..7ddb0b03f 100644 --- a/tools/runsparkd.cmd +++ b/tools/runsparkd.cmd @@ -1 +1,2 @@ -@ssh bts@sparkvm -p 22 "cd /home/bts/spark/build/ninja_debug/src/server/sparkd/ && ./sparkd %*" +@if "%SPARKVM_PORT%"=="" set SPARKVM_PORT=22 +@ssh bts@sparkvm -p %SPARKVM_PORT% "cd /home/bts/spark/build/ninja_debug/src/server/sparkd/ && ./sparkd %*" From cd5c329babc69b8ea30dfe09c3b7617079f36f2a Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Fri, 10 Nov 2017 17:15:27 -0500 Subject: [PATCH 12/29] IEnumerable.Cast does not run implicit conversion operators --- .../GlobalExtensions/GenericCollectionExtensions.cs | 1 + src/client/spark/mspark/Shell/MarketModule.cs | 2 +- .../mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs | 2 +- src/client/spark/mspark/Shell/TradesModule.cs | 2 +- .../spark/view/Controls/PriceEntryControl.xaml.cs | 10 +++++----- .../spark/view/Converters/TickDisplayConverter.cs | 6 +++--- .../api/service_compiler/templates/c#/immutable.pb.cs | 2 +- 7 files changed, 13 insertions(+), 12 deletions(-) diff --git a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs index ff184043b..a9b506ddb 100644 --- a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs +++ b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs @@ -128,6 +128,7 @@ namespace System.Collections.ObjectModel public static class ObservableCollectionExtensions { public static int RemoveAll(this ObservableCollection collection, Func match) { + if (collection == null) return 0; // In terms of allocations we could do this more efficiently by copying items from the end of the // collection in (see https://referencesource.microsoft.com/#q=RemoveAll) but that would allow // transient duplication in the list which could be observed from the outside diff --git a/src/client/spark/mspark/Shell/MarketModule.cs b/src/client/spark/mspark/Shell/MarketModule.cs index cd75859ba..3b88bd3f4 100644 --- a/src/client/spark/mspark/Shell/MarketModule.cs +++ b/src/client/spark/mspark/Shell/MarketModule.cs @@ -68,7 +68,7 @@ namespace mbts.spark if (_securities != null && _securities.TryGetValue((uint)header.version, out SecurityMD md)) return create_ladder_window(md); else break; case MarketViewVM.SAVE_NAME: - if (try_deserialize(load_stream, out MarketViewVM.StartupData data)) return create_market_view(data.securities.Select(deserialize).Cast().ToList(), data.sorting_criteria); + if (try_deserialize(load_stream, out MarketViewVM.StartupData data)) return create_market_view(data.securities.Select(x => (SecurityImmutable)deserialize(x)).ToList(), data.sorting_criteria); else break; } } diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs index 103d59f7f..aba5d04e3 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs @@ -13,7 +13,7 @@ namespace mbts.spark internal class TimeAndSalesWindow : IShellWindow { public TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities) : this (owner, bus, securities, null) { } - public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data) : this(owner, bus, startup_data.securities.Select(deserialize).Cast().ToList(), startup_data.sorting_criteria) { } + public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data) : this(owner, bus, startup_data.securities.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria) { } private TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { _bus = bus; diff --git a/src/client/spark/mspark/Shell/TradesModule.cs b/src/client/spark/mspark/Shell/TradesModule.cs index 41aa7152d..54b03548e 100644 --- a/src/client/spark/mspark/Shell/TradesModule.cs +++ b/src/client/spark/mspark/Shell/TradesModule.cs @@ -68,7 +68,7 @@ namespace mbts.spark return ShellWindow.create(this, "Order Book", view, vm.get_state); } - private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(deserialize).Cast().ToList(), startup_data.sorting_criteria); } + private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria); } private IShellWindow create_fills_window(IReadOnlyCollection securities) { return create_fills_window(securities, null); } private IShellWindow create_fills_window(IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { var vm = new FillsVM(_bus, new OrdersModel(_bus), securities, sorting_criteria); diff --git a/src/client/spark/view/Controls/PriceEntryControl.xaml.cs b/src/client/spark/view/Controls/PriceEntryControl.xaml.cs index 29a5ca5f9..cf7ae26c4 100644 --- a/src/client/spark/view/Controls/PriceEntryControl.xaml.cs +++ b/src/client/spark/view/Controls/PriceEntryControl.xaml.cs @@ -19,7 +19,7 @@ namespace mbts.ui.spark #region Value public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(double), typeof(PriceEntryControl),new FrameworkPropertyMetadata(double.NaN, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, null, CoerceValue)); - private static object CoerceValue(DependencyObject d, object baseValue) { return TickUtils.get_regional_ticks((ContractSpecification)d.GetValue(ContractSpecProperty)).round((double)baseValue); } + private static object CoerceValue(DependencyObject d, object baseValue) { return TickUtils.get_regional_ticks((ContractSpecificationImmutable)d.GetValue(ContractSpecProperty)).round((double)baseValue); } public double Value { get => (double)GetValue(ValueProperty); set => SetValue(ValueProperty, value); } #endregion @@ -36,9 +36,9 @@ namespace mbts.ui.spark #endregion #region ContractSpec - public static readonly DependencyProperty ContractSpecProperty = DependencyProperty.Register("ContractSpec", typeof(ContractSpecification), typeof(PriceEntryControl), new PropertyMetadata(TickUtils.DefaultSpec, OnContractSpecChanged)); + public static readonly DependencyProperty ContractSpecProperty = DependencyProperty.Register("ContractSpec", typeof(ContractSpecificationImmutable), typeof(PriceEntryControl), new PropertyMetadata(TickUtils.DefaultSpec, OnContractSpecChanged)); private static void OnContractSpecChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ((PriceEntryControl)d)._update_text_binding(); } - public ContractSpecificationImmutable ContractSpec { get => GetValue(ContractSpecProperty) as ContractSpecification; set => SetValue(ContractSpecProperty, value); } + public ContractSpecificationImmutable? ContractSpec { get => GetValue(ContractSpecProperty) as ContractSpecificationImmutable?; set => SetValue(ContractSpecProperty, value); } #endregion public PriceEntryControl() { @@ -48,8 +48,8 @@ namespace mbts.ui.spark private TextBox _text; - private void _tick_up() { SetCurrentValue(ValueProperty, ContractSpec.tickup(Value)); } - private void _tick_down() { SetCurrentValue(ValueProperty, ContractSpec.tickdown(Value)); } + private void _tick_up() { SetCurrentValue(ValueProperty, ContractSpec.HasValue ? ContractSpec.Value.tickup(Value) : Value); } + private void _tick_down() { SetCurrentValue(ValueProperty, ContractSpec.HasValue ? ContractSpec.Value.tickdown(Value) : Value); } private void _update_text_binding() { if (_text != null) { diff --git a/src/client/spark/view/Converters/TickDisplayConverter.cs b/src/client/spark/view/Converters/TickDisplayConverter.cs index 1a3deb4b1..309499636 100644 --- a/src/client/spark/view/Converters/TickDisplayConverter.cs +++ b/src/client/spark/view/Converters/TickDisplayConverter.cs @@ -25,16 +25,16 @@ namespace mbts.ui.spark.converters internal class TickDisplayTwoWayConverter : IValueConverter { public bool HideNaN { get; set; } - public ContractSpecificationImmutable ContractSpec { get; set; } = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; + public ContractSpecificationImmutable? ContractSpec { get; set; } = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { var price = (double)value; if (HideNaN && double.IsNaN(price)) return string.Empty; - return ContractSpec.format(price); + return ContractSpec.Value.format(price); } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { - return ContractSpec.parse(value as string); + return ContractSpec.Value.parse(value as string); } } } \ No newline at end of file diff --git a/src/lib/api/service_compiler/templates/c#/immutable.pb.cs b/src/lib/api/service_compiler/templates/c#/immutable.pb.cs index 0fdc36732..1541c11ed 100644 --- a/src/lib/api/service_compiler/templates/c#/immutable.pb.cs +++ b/src/lib/api/service_compiler/templates/c#/immutable.pb.cs @@ -65,7 +65,7 @@ namespace {{package}} { {{else}} {{#if type.islist}} // Can remove the cast if immutable==cstype - public IEnumerable<{{type.immutable}}> {{Name}} => _impl.{{Name}}.Cast<{{type.immutable}}>(); + public IEnumerable<{{type.immutable}}> {{Name}} => _impl.{{Name}}.Select(t => ({{type.immutable}})t); {{else}} public {{type.immutable}} {{Name}} => ({{type.immutable}})_impl.{{Name}}; {{/if}} From 36ab9439a237771fffc951e09f3b632284d7be91 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Fri, 10 Nov 2017 17:38:16 -0500 Subject: [PATCH 13/29] Convert SecuritySelectorControl to use SecurityImmutable --- .../SecurityCollectionView.cs | 4 +-- .../SecuritySelectorControl/SecurityItem.cs | 8 ++--- .../SecuritySelectorControl.xaml.cs | 33 +++++++++---------- .../spark_api/security/SecurityHelper.cs | 4 +-- 4 files changed, 23 insertions(+), 26 deletions(-) diff --git a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs index b086e203f..0760c39cb 100644 --- a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs +++ b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs @@ -12,7 +12,7 @@ using static bts.api.Security; namespace mbts.ui.spark { - public partial class SecuritySelectorControl : Control { + partial class SecuritySelectorControl : Control { internal class SecurityCollectionView : ListCollectionView { public SecurityCollectionView(IList list) : base(list) { } private ReadOnlyObservableCollection _base_groups; @@ -79,7 +79,7 @@ namespace mbts.ui.spark private bool _suspended; private void _cvg_IsAllSelectedChanged() { if(!_suspended) _refresh_is_all_selected(); } - private void _sec_IsSelectedChanged(Security security, bool is_selected) { if (!_suspended) _refresh_is_all_selected(); } + private void _sec_IsSelectedChanged(SecurityImmutable security, bool is_selected) { if (!_suspended) _refresh_is_all_selected(); } private void _refresh_is_all_selected() { bool? new_ias = _get_is_all_selected(); diff --git a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs index d85941db4..f34a27712 100644 --- a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs +++ b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs @@ -6,15 +6,15 @@ using static bts.api.Security; namespace mbts.ui.spark { - public partial class SecuritySelectorControl : Control { + partial class SecuritySelectorControl : Control { internal class SecurityItem : ViewModelBase, ISelectable { - public SecurityItem(Security security, bool is_selected) { + public SecurityItem(SecurityImmutable security, bool is_selected) { this.security = security; _is_selected = is_selected; } private bool _is_selected; - public Security security { get; private set; } + public SecurityImmutable security { get; private set; } public Venue exchange => security.Exchange; public ContractOneofCase type => security.ContractCase; public string symbol => security.ForceSymbol(); @@ -30,7 +30,7 @@ namespace mbts.ui.spark } } } - public event Action IsSelectedChanged; + public event Action IsSelectedChanged; public override int GetHashCode() { return security.Id.GetHashCode(); } } } diff --git a/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs b/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs index 0894e5693..bb101b732 100644 --- a/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs +++ b/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs @@ -12,48 +12,45 @@ using System.Windows.Data; namespace mbts.ui.spark { - /// - /// Interaction logic for SecuritySelectorControl.xaml - /// - public partial class SecuritySelectorControl : Control + partial class SecuritySelectorControl : Control { static SecuritySelectorControl() { DefaultStyleKeyProperty.OverrideMetadata(typeof(SecuritySelectorControl), new FrameworkPropertyMetadata(typeof(SecuritySelectorControl))); } public SecuritySelectorControl() { - SetCurrentValue(SecuritiesProperty, new ObservableCollection()); - SetCurrentValue(SelectedSecuritiesProperty, new ObservableCollection()); + SetCurrentValue(SecuritiesProperty, new ObservableCollection()); + SetCurrentValue(SelectedSecuritiesProperty, new ObservableCollection()); } public static readonly DependencyProperty SelectionModeProperty = DependencyProperty.Register("SelectionMode", typeof(SelectionMode), typeof(SecuritySelectorControl), new PropertyMetadata(SelectionMode.Multiple)); public SelectionMode SelectionMode { get => (SelectionMode)GetValue(SelectionModeProperty); set => SetValue(SelectionModeProperty, value); } #region Securities - public static readonly DependencyProperty SecuritiesProperty = DependencyProperty.Register("Securities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSecuritiesChanged)); + public static readonly DependencyProperty SecuritiesProperty = DependencyProperty.Register("Securities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSecuritiesChanged)); private static void OnSecuritiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { - var securities = e.NewValue as ObservableCollection; + var securities = e.NewValue as ObservableCollection; if (securities != null) { var target = (SecuritySelectorControl)d; - target.InternalSecurityItems = new ObservableAutoWrapper(securities, target._create_security_item); + target.InternalSecurityItems = new ObservableAutoWrapper(securities, target._create_security_item); } } - private SecurityItem _create_security_item(Security s) { + private SecurityItem _create_security_item(SecurityImmutable s) { var selected_securities = SelectedSecurities; var item = new SecurityItem(s, selected_securities != null && selected_securities.Contains(s)); item.IsSelectedChanged += _internal_security_item_IsSelectedChanged; return item; } - public ObservableCollection Securities { get => GetValue(SecuritiesProperty) as ObservableCollection; set => SetValue(SecuritiesProperty, value); } + public ObservableCollection Securities { get => GetValue(SecuritiesProperty) as ObservableCollection; set => SetValue(SecuritiesProperty, value); } #endregion #region SelectedSecurities - public static readonly DependencyProperty SelectedSecuritiesProperty = DependencyProperty.Register("SelectedSecurities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSelectedSecuritiesChanged)); + public static readonly DependencyProperty SelectedSecuritiesProperty = DependencyProperty.Register("SelectedSecurities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSelectedSecuritiesChanged)); private static void OnSelectedSecuritiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var target = (SecuritySelectorControl)d; - var old_val = e.OldValue as ObservableCollection; + var old_val = e.OldValue as ObservableCollection; if (old_val != null) old_val.CollectionChanged -= target.SelectedSecurities_CollectionChanged; - var new_val = e.NewValue as ObservableCollection; + var new_val = e.NewValue as ObservableCollection; if (new_val != null) { target._selected_securities_changing = true; foreach (var item in target.InternalSecurityItems) item.is_selected = new_val.Contains(item.security); @@ -67,8 +64,8 @@ namespace mbts.ui.spark _selected_securities_changing = true; var items = InternalSecurityItems; switch (e.Action) { - case NotifyCollectionChangedAction.Add: foreach (Security s in e.NewItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = true); break; - case NotifyCollectionChangedAction.Remove: foreach (Security s in e.OldItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = false); break; + case NotifyCollectionChangedAction.Add: foreach (SecurityImmutable s in e.NewItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = true); break; + case NotifyCollectionChangedAction.Remove: foreach (SecurityImmutable s in e.OldItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = false); break; default: var selected_securities = SelectedSecurities; foreach (SecurityItem si in items) si.is_selected = selected_securities.Contains(si.security); @@ -77,7 +74,7 @@ namespace mbts.ui.spark _selected_securities_changing = false; } } - public ObservableCollection SelectedSecurities { get => GetValue(SelectedSecuritiesProperty) as ObservableCollection; set => SetValue(SelectedSecuritiesProperty, value); } + public ObservableCollection SelectedSecurities { get => GetValue(SelectedSecuritiesProperty) as ObservableCollection; set => SetValue(SelectedSecuritiesProperty, value); } #endregion #region InternalSecurityItems @@ -96,7 +93,7 @@ namespace mbts.ui.spark } } private void _internal_security_items_ViewDestroyed(SecurityItem item) { item.IsSelectedChanged -= _internal_security_item_IsSelectedChanged; } - private void _internal_security_item_IsSelectedChanged(Security security, bool is_selected) { + private void _internal_security_item_IsSelectedChanged(SecurityImmutable security, bool is_selected) { if (!_selected_securities_changing) { _selected_securities_changing = true; if (is_selected) SelectedSecurities.Add(security); diff --git a/src/client/spark_api/security/SecurityHelper.cs b/src/client/spark_api/security/SecurityHelper.cs index 8b874c083..674bc67cc 100644 --- a/src/client/spark_api/security/SecurityHelper.cs +++ b/src/client/spark_api/security/SecurityHelper.cs @@ -46,12 +46,12 @@ namespace bts.api internal static int SignedQuantity(this ContractLegImmutable leg) { return leg.Side == Side.Buy ? (int)leg.Quantity : -(int)leg.Quantity; } - internal static string ForceSymbol(this Security security) { + internal static string ForceSymbol(this SecurityImmutable security) { if (security.ContractCase == ContractOneofCase.Synthetic) return ForceSymbol(security.Synthetic.Legs.First().Security); else return security.Symbol; } - public static string DisplayExchange(this Security security) { + public static string DisplayExchange(this SecurityImmutable security) { return security.ContractCase == ContractOneofCase.Synthetic ? $"[{string.Join(",", get_flat_future_legs(security).Select(flt => flt.Item1.ToString()).Distinct().OrderBy(e => e))}]" : security.Exchange.ToString(); } #endregion From 7bd1302f2239a661bd570dc4c8d205cdf9be2c3d Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 10 Nov 2017 17:50:35 -0500 Subject: [PATCH 14/29] Spark-267 better logging --- .../spreader_orders/SpreaderOrder.cpp | 27 ++----- .../orderman/spreader_orders/SpreaderOrder.h | 10 ++- .../SpreaderEndStateWorker.cpp | 8 +- ...SpreaderWaitingForCancelAllStateWorker.cpp | 33 ++++---- ...SpreaderWaitingForFirstConnStateWorker.cpp | 11 +-- .../SpreaderWorkingStateWorker.cpp | 80 +++++++++---------- 6 files changed, 78 insertions(+), 91 deletions(-) diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index be177b970..ca76f544e 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -138,31 +138,31 @@ void SpreaderOrder::_transform_to_START() { bts_assert (_state_worker == nullptr); _switch_state (&_start_state_worker); - report_state (api::orderman::OrderStatus::OS_PENDING_NEW); + _report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderOrder::_transform_to_WAITING_FOR_FIRST_CONNECTION() { bts_assert(_state_worker->state() == SpreaderState::START); _switch_state(&_waiting_for_first_conn_state_worker); - report_state (api::orderman::OrderStatus::OS_PENDING_NEW); + _report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderOrder::_transform_to_WORKING() { bts_assert(_state_worker->state() == SpreaderState::WAITING_FOR_FIRST_CONNECT); _switch_state(&_working_state_worker); - report_state (api::orderman::OrderStatus::OS_NEW); + _report_state (api::orderman::OrderStatus::OS_NEW); } void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL() { bts_assert(_state_worker->state() == SpreaderState::WORKING); _switch_state(&_waiting_for_cancel_all_state_worker); - report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); + _report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); } -void SpreaderOrder::_transform_to_END() +void SpreaderOrder::_transform_to_END(std::string* m) { bts_assert(_state_worker->state() != SpreaderState::END); _switch_state(&_end_state_worker); - report_state (api::orderman::OrderStatus::OS_DONE); + _report_state (api::orderman::OrderStatus::OS_DONE, m); } void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) { @@ -259,22 +259,13 @@ void SpreaderOrder::_compute_hedge_price_quantity(size_t, Price&, Quantity&) { } -void SpreaderOrder::report_state (api::orderman::OrderStatus order_status) +void SpreaderOrder::_report_state (api::orderman::OrderStatus order_status, std::string* m) { report_state_change(SpreaderOrderState{ order_status, _bookkeeping_data.price(), _bookkeeping_data.quantity(), - nullptr - }); -} -void SpreaderOrder::report_state (api::orderman::OrderStatus order_status, std::string& message) -{ - report_state_change(SpreaderOrderState{ - order_status, - _bookkeeping_data.price(), - _bookkeeping_data.quantity(), - message.empty() ? nullptr : &message + m }); } void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state) @@ -283,8 +274,6 @@ void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state) _state_worker = new_state; _state_worker->build_once (this); } -SpreaderBookkeepingData& SpreaderOrder::bookkeeping_data () {return _bookkeeping_data;} - /*******************************************************************************/ /***************************Functions to Help Testing****************************/ SpreaderState SpreaderOrder::test_only_func_state() {return _state_worker->state();} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index 814e399e5..9677c9ff3 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -77,7 +77,7 @@ private: void _transform_to_WAITING_FOR_FIRST_CONNECTION(); void _transform_to_WORKING(); void _transform_to_WAITING_FOR_CANCEL_ALL(); - void _transform_to_END(); + void _transform_to_END(std::string* m = nullptr); // this cancels the quoters and hedger orders (through them); // can cancel the quotes or the hedges or both void _cancel_orders(bool cancel_quotes, bool cancel_hedges); @@ -86,7 +86,10 @@ private: bool _all_quoter_orders_in_terminal_state(); // same as _all_quoter_orders_in_terminal_state, for hedgers bool _all_hedger_orders_in_terminal_state(); + // sends all the quoters immedatly to the their terminal state + // abandoning everything they were doing void _terminate_quoters (); + // same as the above for hedgers void _terminate_hedgers(); bool _quoters_can_accept_modification(); void _send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_to_hedge_index); @@ -94,11 +97,10 @@ private: Price filled_price, Quantity filled_quantity, size_t hedged_index, Price& hedge_price, Quantity& hedge_quantity); - void report_state (api::orderman::OrderStatus order_status); - void report_state (api::orderman::OrderStatus order_status, std::string& message); - SpreaderBookkeepingData& bookkeeping_data (); + void _report_state (api::orderman::OrderStatus order_status, std::string* message = nullptr); void _switch_state (ISpreaderStateWorker* new_state); private: + std::string _msg; const bool _active; const api::orderman::CreateOrderRequest _create_order_request; SpreaderBookkeepingData _bookkeeping_data; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp index 7197fba75..7d6ca0207 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp @@ -13,9 +13,7 @@ void SpreaderEndStateWorker::build_once (SpreaderOrder* spreader) } void SpreaderEndStateWorker::init () { - // all error-free order status updates in this state (and the next) - // are OS_PENDING_NEW. order goes to OS_NEW once it is WORKING - bts_assert_msg(false, "Illegal Spreader operation {END,on_connect}"); + bts_assert_msg (false, "SpreaderEndStateWorker::init is an illegal operation"); } void SpreaderEndStateWorker::on_connect() { @@ -43,12 +41,10 @@ void SpreaderEndStateWorker::on_hedger_order_error(OrderKey, api::orderman::Orde {} void SpreaderEndStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) {} -void SpreaderEndStateWorker::on_external_error(std::string const& err_msg) +void SpreaderEndStateWorker::on_external_error(std::string const&) { - LOG(OrderMan, Warn, "SpreaderEndStateWorker.on_external_error err_msg:{}", err_msg); } void SpreaderEndStateWorker::on_check_termination () { } - }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp index 03f8df81c..fbb902cc1 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp @@ -13,26 +13,23 @@ void SpreaderWaitingForCancelAllStateWorker::build_once (SpreaderOrder* spreader } void SpreaderWaitingForCancelAllStateWorker::init () { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_CANCEL_ALL,init}"); + bts_assert_msg (false, "SpreaderWaitingForCancelAllStateWorker::init is an illegal operation"); } void SpreaderWaitingForCancelAllStateWorker::on_connect() { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_CANCEL_ALL,on_connect}"); + bts_assert_msg (false, "SpreaderWaitingForCancelAllStateWorker::on_connect is an illegal operation"); } void SpreaderWaitingForCancelAllStateWorker::on_disconnect() { _spreader->_terminate_quoters(); _spreader->_terminate_hedgers (); - _spreader->report_state (api::orderman::OrderStatus::OS_STOPPED); _spreader->_transform_to_END (); } void SpreaderWaitingForCancelAllStateWorker::on_update(const api::orderman::UpdateSpreaderOrder&) { - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK); } void SpreaderWaitingForCancelAllStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { - // nothing already waiting for cancel } void SpreaderWaitingForCancelAllStateWorker::on_book(TickToTradeCorID, Book const&) { @@ -41,9 +38,10 @@ void SpreaderWaitingForCancelAllStateWorker::on_time(const TimeStamp&) { // TODO, if enough time has elapsed then tranform to end } -void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*) +void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { - // on_error results in cancelling, however this is already waiting for cancel here + leg_data.order_update_message().update (status, filled_quantity, average_price, err_msg); + leg_data.quoter().update_order_status (leg_data.order_update_message()); } void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) @@ -55,13 +53,23 @@ void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_status_update(bts:: { leg_data.order_update_message().update (status); } -void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) +void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { - // on_error results in cancelling, however this is already waiting for cancel here + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, err_msg); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } } -void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) +void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) { - // TODO, update hedger + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, nullptr); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } } void SpreaderWaitingForCancelAllStateWorker::on_external_error(std::string const&) { @@ -69,9 +77,6 @@ void SpreaderWaitingForCancelAllStateWorker::on_external_error(std::string const void SpreaderWaitingForCancelAllStateWorker::on_check_termination() { if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) - { - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); // TODO, figure out if it was filled or cxl'ed _spreader->_transform_to_END (); - } } }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp index 64f8d11e8..f154e91c9 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp @@ -35,8 +35,7 @@ void SpreaderWaitingForFirstConnStateWorker::on_connect() // if securities can not be resolved, the order is terminated LOG(OrderMan, Diag, "SpreaderWaitingForFirstConnStateWorker.on_connect key: {} , could not resolve securities", _spreader->key().value()); std::string msg = "Could not resolve securities"; - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg); - _spreader->_transform_to_END (); + _spreader->_transform_to_END (&msg); } } void SpreaderWaitingForFirstConnStateWorker::on_disconnect() @@ -49,7 +48,8 @@ void SpreaderWaitingForFirstConnStateWorker::on_update(const api::orderman::Upda } void SpreaderWaitingForFirstConnStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { - _spreader->_transform_to_END(); + std::string msg = "Order cancelled"; + _spreader->_transform_to_END(&msg); } void SpreaderWaitingForFirstConnStateWorker::on_book(TickToTradeCorID, Book const&) { @@ -78,9 +78,10 @@ void SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update(OrderKey, ap { bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update is an illegal operation"); } -void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const&) +void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const& err_msg) { - _spreader->_transform_to_END (); + std::string msg = "Error message: " + err_msg; + _spreader->_transform_to_END (&msg); } void SpreaderWaitingForFirstConnStateWorker::on_check_termination() {} diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 865094ca0..029baec1a 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -13,47 +13,42 @@ void SpreaderWorkingStateWorker::build_once (SpreaderOrder* spreader) } void SpreaderWorkingStateWorker::init () { - bts_assert_msg(false, "Illegal Spreader operation {WORKING,init}"); + bts_assert_msg (false, "SpreaderWorkingStateWorker::init is an illegal operation"); } void SpreaderWorkingStateWorker::on_connect() { - bts_assert_msg(false, "Illegal Spreader operation {WORKING,on_connect}"); + bts_assert_msg (false, "SpreaderWorkingStateWorker::on_connect is an illegal operation"); } void SpreaderWorkingStateWorker::on_disconnect() { _spreader->_terminate_quoters (); _spreader->_terminate_hedgers(); - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); - _spreader->_transform_to_END (); + _spreader->_msg = "disconnected"; + _spreader->_transform_to_END (&(_spreader->_msg)); } -void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update) +void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& u) { if (_spreader->_quoters_can_accept_modification()) { - Price new_price (order_update.price()); Quantity new_quantity (order_update.quantity()); - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); - // updating internal state - _spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity())); - // updating all active quoters - for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++) + Price price (u.price()); Quantity quantity(u.quantity()); + _spreader->_bookkeeping_data.update_order (price, quantity); + // updating all active quoters, nothing to do with the hedgers + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data.is_active_quoting()) - leg_data.quoter().update_order_price_quantity (new_price, new_quantity); + leg_data.quoter().update_order_price_quantity (price, quantity); } - // reporting state - _spreader->report_state (api::orderman::OrderStatus::OS_NEW); } } void SpreaderWorkingStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book) { - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); + SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data; // this is a key->index lookup SpreaderLegData& md_leg = bookkeeping_data.get_leg_data(book.security_key()); // updating md state (this is the only place where its done) @@ -67,22 +62,20 @@ void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book) } // send md to hedgers hedging this security only for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++) - { - SpreaderHedgerData& h = md_leg.get_hedger(h_idx); - h.hedger().on_book(cid, book); - } + md_leg.get_hedger(h_idx).hedger().on_book(cid, book); } -void SpreaderWorkingStateWorker::on_time(const TimeStamp&) +void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts) { - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); + SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data; for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++) { - SpreaderLegData& d = bookkeeping_data.get_leg_data(q_idx); - if (d.leg_property_data.is_active_quoting()) + SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx); + if (leg_data.leg_property_data.is_active_quoting()) { - // same f'ing timestamp - // d.quoter().on_time (ts); - } + leg_data.quoter().on_time(ts); + for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) + leg_data.get_hedger(h_idx).hedger().on_time (ts); + } } } void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) @@ -91,7 +84,6 @@ void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLe // this is because the error message could also have status changes leg_data.quoter().update_order_status (leg_data.order_update_message()); _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) @@ -104,10 +96,9 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg // 5. init the hedger leg_data.order_update_message().update (status, filled_quantity, average_price, nullptr); leg_data.quoter().update_order_status (leg_data.order_update_message()); - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); - for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data.count(); q_idx++) { - bts::orderman::SpreaderLegData other_leg_data = bookkeeping_data.get_leg_data (q_idx); + bts::orderman::SpreaderLegData other_leg_data = _spreader->_bookkeeping_data.get_leg_data (q_idx); if (q_idx != leg_data.leg_property_data.leg_index) { // if it is an actively quoting leg, inform the quoter about it @@ -124,31 +115,34 @@ void SpreaderWorkingStateWorker::on_quoter_order_status_update(bts::orderman::Sp leg_data.order_update_message().update (status); leg_data.quoter().update_order_status (leg_data.order_update_message()); } -void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) +void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { - // TODO:update hedger order state - //leg_data.order_update_message().update(status, filled_quantity, average_price, err_msg); + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, err_msg); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } -void SpreaderWorkingStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) +void SpreaderWorkingStateWorker::on_hedger_order_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) { - // TODO - bts_assert_msg (false, "Illegal Spreader operation {WORKING,on_hedger_order_upate}"); + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, nullptr); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } } void SpreaderWorkingStateWorker::on_external_error(std::string const&) { _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } void SpreaderWorkingStateWorker::on_check_termination() { if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) - { - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); // TODO, figure out if it was filled or cxl'ed _spreader->_transform_to_END (); - } } }} \ No newline at end of file From 3e025f180525117685f1b4649d4e001af8911ba3 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Fri, 10 Nov 2017 18:30:38 -0500 Subject: [PATCH 15/29] spark-267 done --- src/server/sparkd/spreader/SpreaderLegData.h | 25 ++++++++++---------- 1 file changed, 12 insertions(+), 13 deletions(-) diff --git a/src/server/sparkd/spreader/SpreaderLegData.h b/src/server/sparkd/spreader/SpreaderLegData.h index 10e094e7b..af03354f4 100644 --- a/src/server/sparkd/spreader/SpreaderLegData.h +++ b/src/server/sparkd/spreader/SpreaderLegData.h @@ -56,18 +56,17 @@ public: return nullptr; } // adds a new hedger with the given values -// SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager, -// size_t leg_index, -// const OrderTemplate& order_template, -// const LegPropertyData& leg_property_data, -// bts::Price hedge_price, -// bts::Quantity hedge_quantity, -// api::Side hedge_side) -// { -// SingleFillHedger hedger(spreader_manager, leg_index, order_template, leg_property_data, hedge_price, hedge_quantity, hedge_side); -// SpreaderHedgerData hedger_data(hedger); -// _hedger_data_vector.push_back(hedger_data); -// return _hedger_data_vector.back(); -// } + SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager, + bts::orderman::SpreaderOrderBase::ChildOrder order, + bts::Price hedge_price, + bts::Quantity hedge_quantity, + api::Side hedge_side) + { + SpreaderOrderUpdateMessage hedger_order_update (order.order_key()); + SingleFillHedger hedger(spreader_manager, leg_property_data, order, hedge_price, hedge_quantity, hedge_side); + SpreaderHedgerData hedger_data(hedger, hedger_order_update); + _hedger_data_vector.push_back(hedger_data); + return _hedger_data_vector.back(); + } }; }} \ No newline at end of file From 0514b84f42bc26db7d8b6abd5a8e4403f58bafab Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Sun, 12 Nov 2017 22:00:44 -0500 Subject: [PATCH 16/29] order generation done in one place only --- .../spreader_orders/SpreaderOrder.cpp | 39 ++++++++++++------- .../orderman/spreader_orders/SpreaderOrder.h | 11 +++++- ...SpreaderWaitingForFirstConnStateWorker.cpp | 7 +--- .../SpreaderWorkingStateWorker.cpp | 2 +- 4 files changed, 39 insertions(+), 20 deletions(-) diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index ca76f544e..03feae2b7 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -239,25 +239,30 @@ bool SpreaderOrder::_quoters_can_accept_modification () } return true; } -void SpreaderOrder::_send_hedge(size_t, Price, Quantity, size_t) +void SpreaderOrder::_send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, + size_t hedge_leg_index) { -// for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) -// { -// SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); -// for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) -// { -// SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); -// hedger_data.hed -// if (!hedger_data.hedger().is_terminal_state()) -// return false; -// } -// } + Price hedge_price; + Quantity hedge_quantity; + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data (hedge_leg_index); + _compute_hedge_price_quantity (filled_leg_index, filled_price, filled_quantity, hedge_leg_index, + hedge_price, hedge_quantity); + bts::orderman::SpreaderOrderBase::ChildOrder new_hedge_order = _get_new_order (leg_data.leg_property_data, false); + SpreaderHedgerData& hedger_data = leg_data.add_new_hedger (*this, new_hedge_order, hedge_price, hedge_quantity,leg_data.leg_property_data.trading_side); + hedger_data.hedger().init (); } void SpreaderOrder::_compute_hedge_price_quantity(size_t, Price, Quantity, size_t, Price&, Quantity&) { + // 2 cases + if (_bookkeeping_data.count() == 2) + { + } + else + { + } } void SpreaderOrder::_report_state (api::orderman::OrderStatus order_status, std::string* m) { @@ -270,10 +275,18 @@ void SpreaderOrder::_report_state (api::orderman::OrderStatus order_status, std: } void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state) { - LOG(OrderMan, Diag, "SpreaderOrder::_switch_state key: {}, {} -> {} ", key().value(), (_state_worker == nullptr ? "NULL" : _state_worker->state_text()), new_state->state_text()); + LOG(OrderMan, Info, "SpreaderOrder::_switch_state key: {}, {} -> {} ", key().value(), (_state_worker == nullptr ? "NULL" : _state_worker->state_text()), new_state->state_text()); _state_worker = new_state; _state_worker->build_once (this); } +bts::orderman::SpreaderOrderBase::ChildOrder SpreaderOrder::_get_new_order (const LegPropertyData& leg_property_data, bool is_quote_order) +{ + bts::SecurityKey sec_key = bts::SecurityKey (leg_property_data.security_key()); + api::Security const* db_sec = _db().resolve (sec_key); + api::orderman::ChildOrderKind order_type = is_quote_order ? api::orderman::ChildOrderKind::COK_SPREADER_QUOTING : api::orderman::ChildOrderKind::COK_SPREADER_HEDGING; + bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(*db_sec, leg_property_data.trading_side, order_type); + return child_factory(); +} /*******************************************************************************/ /***************************Functions to Help Testing****************************/ SpreaderState SpreaderOrder::test_only_func_state() {return _state_worker->state();} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index 9677c9ff3..0ba979561 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -92,13 +92,22 @@ private: // same as the above for hedgers void _terminate_hedgers(); bool _quoters_can_accept_modification(); + // this sends a hedge (creates a hedger and inits it) + // on leg 'leg_to_hedge_index' in response to a fill + // in leg 'filled_leg_index' with price 'filled_price' + // quantity 'filled_quantity' void _send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_to_hedge_index); + // purely a computating function that computes the + // hedge price and quantity (last 2 args) for leg + // 'hedged_leg_index' for a fill on leg 'filled_leg_index' + // with price 'filled_price' and quantity 'filled_quantity' void _compute_hedge_price_quantity(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, - size_t hedged_index, + size_t hedged_leg_index, Price& hedge_price, Quantity& hedge_quantity); void _report_state (api::orderman::OrderStatus order_status, std::string* message = nullptr); void _switch_state (ISpreaderStateWorker* new_state); + bts::orderman::SpreaderOrderBase::ChildOrder _get_new_order (const LegPropertyData& leg_property_data, bool is_quote_order); private: std::string _msg; const bool _active; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp index f154e91c9..a30405b94 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp @@ -144,15 +144,12 @@ void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quo { // i. immutable property data for this leg const bts::api::ContractLeg& leg = *it; - uint32_t leg_key = leg.security().id(); - auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg_key); + auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id()); bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end()); api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg); LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side); // ii. setting up the order for this leg - api::Security const* db_sec = _spreader->_db().resolve (bts::SecurityKey (leg_key)); - bts::orderman::SpreaderOrderBase::ChildFactory child_factory = _spreader->get_child_factory(*db_sec, leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); - bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory(); + bts::orderman::SpreaderOrderBase::ChildOrder child_order = _spreader->_get_new_order (leg_property_data, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); LOG(OrderMan, Diag, "Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), _spreader->key().value()); // iii. setting up the quoter (which needs the quoter and property from i and ii) SingleLegQuoter leg_quoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order); diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 029baec1a..716ed4cd1 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -105,7 +105,7 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg // so it can decrease the proportional size if (other_leg_data.leg_property_data.is_active_quoting()) other_leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data.leg_index, filled_quantity); - // a hedge is sent regsardless + // a hedge is sent regardless _spreader->_send_hedge (leg_data.leg_property_data.leg_index, average_price, filled_quantity, q_idx); } } From ae5a6d2493dbd2192b560c63b39ee35121458de8 Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 13 Nov 2017 09:19:40 -0500 Subject: [PATCH 17/29] Fixed some warnings reported by newer clang. --- src/lib/logging/LoggerHub.cpp | 2 +- src/lib/quickbus/pubsub/tests/qb_pubsub_tests.cpp | 2 +- src/server/sparkd/jetfix/codec/Group.h | 1 - src/server/sparkd/jetfix/connection/SocketConnection.cpp | 1 + src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.h | 2 +- src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h | 2 +- 6 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/lib/logging/LoggerHub.cpp b/src/lib/logging/LoggerHub.cpp index 37aaf35f0..a3db68bfe 100644 --- a/src/lib/logging/LoggerHub.cpp +++ b/src/lib/logging/LoggerHub.cpp @@ -142,7 +142,7 @@ size_t LoggerHub::consume_log_recs() size_t consumed = 0; for (size_t i = 0; i < me->loggers.size();i++) { auto &l = me->loggers[i]; - l->unqueue([&l,&to_keep,i,&consumed,this] (std::thread::id tid, bool active, + l->unqueue([&l,&to_keep,&consumed,this] (std::thread::id tid, bool active, size_t dropped_msg_count, size_t logged_msg_count, std::vector &msgs) { diff --git a/src/lib/quickbus/pubsub/tests/qb_pubsub_tests.cpp b/src/lib/quickbus/pubsub/tests/qb_pubsub_tests.cpp index 132767ed9..98b7e3672 100644 --- a/src/lib/quickbus/pubsub/tests/qb_pubsub_tests.cpp +++ b/src/lib/quickbus/pubsub/tests/qb_pubsub_tests.cpp @@ -203,7 +203,7 @@ TEST_CASE("Quickbus Pubsub Tests","[quickbus]") bool sub2_got_a = false; bool sub2_got_b = false; auto f2 = p2.get_future(); - TableSubscriber sub2 (qb,equal_topic(Topic("A")),[&p2,&sub2_got_b,&sub2_got_a] (TableEvent const&ev) { + TableSubscriber sub2 (qb,equal_topic(Topic("A")),[&sub2_got_b,&sub2_got_a] (TableEvent const&ev) { if (ev.event_type == TableEvent::TABLE_UPDATED) { REQUIRE(ev.update); REQUIRE(ev.update->size() == 1); diff --git a/src/server/sparkd/jetfix/codec/Group.h b/src/server/sparkd/jetfix/codec/Group.h index a703b9128..51e6def20 100644 --- a/src/server/sparkd/jetfix/codec/Group.h +++ b/src/server/sparkd/jetfix/codec/Group.h @@ -110,7 +110,6 @@ public: void write (WriterCursor &cursor) { - WriterCursor::Loc dummy_result; CountField::write (cursor,(int) size ()); for (auto &el : _elements) el.write (cursor); diff --git a/src/server/sparkd/jetfix/connection/SocketConnection.cpp b/src/server/sparkd/jetfix/connection/SocketConnection.cpp index 2b72dc7cb..643fd06b9 100644 --- a/src/server/sparkd/jetfix/connection/SocketConnection.cpp +++ b/src/server/sparkd/jetfix/connection/SocketConnection.cpp @@ -10,6 +10,7 @@ #include #include #include +#include namespace bts { namespace jetfix { diff --git a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.h b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.h index 8e6eb7b38..67078c9b7 100644 --- a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.h +++ b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.h @@ -19,7 +19,7 @@ class MDP3Listener : { public: MDP3Listener(CMESecurityIndex& index, md2::MDProducer&, md2::SecurityIDRecorder&, co2::SettlementRecorder&, std::vector, utils::Dispatcher&); - ~MDP3Listener(); + virtual ~MDP3Listener(); // // Warnings/Errors/Info diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h index f8e1c719f..311992c68 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h @@ -37,7 +37,7 @@ public: NativeOrderFactory &, OrderKey , api::orderman::CreateOrderRequest const&); - ~SpreaderOrderBase(); + virtual ~SpreaderOrderBase(); void init_signals(event_grid::Signal const&, event_grid::Signal const&, From c44282085ed5023d6a744c1ea18a6a9a4d54cac8 Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 13 Nov 2017 09:22:11 -0500 Subject: [PATCH 18/29] Tweaks to order building. --- src/server/sparkd/cmds/Benchmark.cpp | 218 ++++++++++++++++-- .../sparkd/orderman/doc/order_man_notes.org | 103 ++++++--- .../orderman/native_orders/NativeOrder.h | 2 +- .../native_orders/NativeOrderBuilder.cpp | 2 +- .../native_orders/NativeOrderFactory.cpp | 9 +- 5 files changed, 274 insertions(+), 60 deletions(-) diff --git a/src/server/sparkd/cmds/Benchmark.cpp b/src/server/sparkd/cmds/Benchmark.cpp index ac0f3b3fa..c28ce390a 100644 --- a/src/server/sparkd/cmds/Benchmark.cpp +++ b/src/server/sparkd/cmds/Benchmark.cpp @@ -1,49 +1,223 @@ #include "Benchmark.h" +#include "lib/utils/PBUtils.h" #include "server/sparkd/cmds/CmdRegistry.h" -#include +#include "server/sparkd/orderman/native_orders/NativeOrder.h" +#include "lib/utils/Puid.h" +#include "server/sparkd/orderman/persistence/gen_order_id.h" +#include "lib/api/services/OrderService.pb.h" #include +#include +#include namespace bts { namespace cmd { -static void BM_StringCreation(benchmark::State& state) { +auto sec_str = " id: 3\n" + " symbol: \"ES\"\n" + " exchange: VENUE_GLBX\n" + " contract_spec {\n" + " low_tick: 0.25\n" + " high_tick: 0.25\n" + " cash_per_point: 50\n" + " price_multiplier: 0.01\n" + " }\n" + " future {\n" + " expiration_year: 2018\n" + " expiration_month: 9\n" + " expiration_day: 1\n" + " }\n" + " glbx {\n" + " exchange_id: 57287\n" + " security_desc: \"ESU8\"\n" + " cfi_code: \"FFIXSX\"\n" + " cme_symbol: \"ES\"\n" + " }\n"; + +auto order_str = " order_key: 189285\n" + " timestamp {\n" + " seconds: 1509644176\n" + " nanos: 717250000\n" + " }\n" + " native {\n" + " account_name: \"BTS \"\n" + " operator_id: \"BTS \"\n" + " security_key: 3\n" + " side: SIDE_BUY\n" + " time_in_force: TIF_DAY\n" + " manual_order_indicator: MOI_YES\n" + " order_type: OT_LIMIT\n" + " price: 2500\n" + " order_quantity: 12\n" + " }\n" + " customer_or_firm: COF_FIRM\n" + " cti_code: CTI_CTI1\n" + " order_status: OS_UNACKNOWLEDGED\n"; + +static void create_native_order_from_header(benchmark::State &state) { + + auto sec = utils::pb::from_string(sec_str); + auto order_state = + utils::pb::from_string(order_str); + auto &native = order_state.native(); + + auto header = orderman::NativeOrderHeader { + orderman::null_order_key(), + orderman::null_order_key(), + api::orderman::COK_UNDEFINED, + &sec, + orderman::to(native.account_name()), + orderman::to(native.operator_id()), + native.side(), + native.time_in_force(), + native.order_type(), + native.manual_order_indicator(), + order_state.customer_or_firm(), + order_state.cti_code() + }; for (auto _ : state) { - std::string empty_string; - benchmark::DoNotOptimize(empty_string.size()); + orderman::NativeOrder n(header); + benchmark::DoNotOptimize(n.can_be_canceled()); } } +BENCHMARK(create_native_order_from_header); -// Register the function as a benchmark -BENCHMARK(BM_StringCreation); +static void compare_native_order_header(benchmark::State &state) { -// Define another benchmark -static void BM_StringCopy(benchmark::State& state) { - std::string x = "hello"; + auto sec = utils::pb::from_string(sec_str); + auto order_state = + utils::pb::from_string(order_str); + auto &native = order_state.native(); + + auto header = orderman::NativeOrderHeader { + orderman::null_order_key(), + orderman::null_order_key(), + api::orderman::COK_UNDEFINED, + &sec, + orderman::to(native.account_name()), + orderman::to(native.operator_id()), + native.side(), + native.time_in_force(), + native.order_type(), + native.manual_order_indicator(), + order_state.customer_or_firm(), + order_state.cti_code() + }; + auto header2 = header; + int i = 0; + auto n = 0; for (auto _ : state) { - std::string copy(x); - benchmark::DoNotOptimize(copy.size()); + header2.side = (api::Side) ((int)header.side + i); + benchmark::DoNotOptimize(n += (header == header2)); } } -BENCHMARK(BM_StringCopy); +BENCHMARK(compare_native_order_header); -int Benchmark::execute(std::vector const &args) -{ +static void create_native_order_from_state(benchmark::State &state) { + + auto sec = utils::pb::from_string(sec_str); + auto order_state = utils::pb::from_string(order_str); + for (auto _ : state) { + orderman::NativeOrder n(sec, order_state); + benchmark::DoNotOptimize(n.can_be_canceled()); + } +} +BENCHMARK(create_native_order_from_state); + +static void create_native_order_header(benchmark::State &state) { + + auto sec = utils::pb::from_string(sec_str); + auto order_state = + utils::pb::from_string(order_str); + auto &native = order_state.native(); + + for (auto _ : state) { + auto header = orderman::NativeOrderHeader { + orderman::null_order_key(), + orderman::null_order_key(), + api::orderman::COK_UNDEFINED, + &sec, + orderman::to(native.account_name()), + orderman::to(native.operator_id()), + native.side(), + native.time_in_force(), + native.order_type(), + native.manual_order_indicator(), + order_state.customer_or_firm(), + order_state.cti_code() + }; + benchmark::DoNotOptimize(header.order_key == orderman::null_order_key()); + } +} +BENCHMARK(create_native_order_header); + +static void gen_id(benchmark::State &state) { + std::string scope = "benchmark"; + + for (auto _ : state) { + auto id = utils::reserve_ids(scope,1); + benchmark::DoNotOptimize(id+1>0); + } + +} +BENCHMARK(gen_id); + +static void copy_native_order_proto_update(benchmark::State &state) { + api::orderman::OrderProtoUpdate master_update; + auto &update = *master_update.mutable_native(); + update.set_price (2500.1); + update.set_quantity(12); + update.set_last_price(2500); + update.set_avg_price(2500); + update.set_filled_quantity(0); + update.set_status(api::orderman::OS_UNACKNOWLEDGED); + update.set_order_id("123154232134234"); + update.set_reject_msg("123154232134234"); + + api::orderman::OrderProtoUpdate cpy(master_update); + + for (auto _ : state) { + master_update.mutable_native()->set_quantity(3); + *cpy.mutable_native() = master_update.native(); + benchmark::DoNotOptimize(cpy.native().quantity() == 3); + } +} +BENCHMARK(copy_native_order_proto_update); + +static void mutex_lock_unlock(benchmark::State &state) { + int i = 0; + std::mutex lock; + for (auto _ : state) { + std::lock_guard l(lock); + benchmark::DoNotOptimize(i++); + } +} +BENCHMARK(mutex_lock_unlock); + +static void spin_lock_unlock(benchmark::State &state) { + int i = 0; + std::atomic_flag _mutex = ATOMIC_FLAG_INIT; + for (auto _ : state) { + while (_mutex.test_and_set(std::memory_order_acquire)); + benchmark::DoNotOptimize(i++); + _mutex.clear(std::memory_order_release); + } +} +BENCHMARK(spin_lock_unlock); + +int Benchmark::execute(std::vector const &args) { bts_assert(args.size() < 100); int argc = args.size(); char *argv[100]; - for (size_t i = 0; i < args.size();i++) - argv[i] = (char*) args[i].c_str(); + for (size_t i = 0; i < args.size(); i++) + argv[i] = (char *)args[i].c_str(); benchmark::Initialize(&argc, argv); benchmark::RunSpecifiedBenchmarks(); return 0; } - -std::string Benchmark::help () -{ - return "Run micro-benchmarks"; + +std::string Benchmark::help() { return "Run micro-benchmarks"; } } - -}} +} diff --git a/src/server/sparkd/orderman/doc/order_man_notes.org b/src/server/sparkd/orderman/doc/order_man_notes.org index a95d3a88c..82b4a21b9 100644 --- a/src/server/sparkd/orderman/doc/order_man_notes.org +++ b/src/server/sparkd/orderman/doc/order_man_notes.org @@ -11,32 +11,68 @@ - [[https://www.cmegroup.com/confluence/display/EPICSANDBOX/Execution+Report+-+Trade+Cancel][Trade Cancel]] - [[https://www.cmegroup.com/confluence/display/EPICSANDBOX/Order%2BCancel%2BReject][Cancel Reject]] * Fields used -| Field | Needed to create | Needed to update | Needed to cancel | Recoverable | Needed for Display | Lifecyle | -|--------------------+------------------+------------------+------------------+-------------+--------------------+--------------| -| security | Y | Y | Y | Y | Y | const,~null | -| account | Y | Y | Y | Y | Y | const,~null | -| operatorid | Y | Y | Y | Y | N | const,~null | -| orderkey | Y | Y | Y | Y | Y | const,~null | -| side | Y | Y | Y | Y | Y | const,~null | -| time_in_force | Y | Y | N | Y | Y | const,~null | -| customer_or_firm | Y | Y | N | N | Y | const,~null | -| cti_code | Y | Y | N | N | Y | const,~null | -| login | N | N | N | N | Y | const,~null | -|--------------------+------------------+------------------+------------------+-------------+--------------------+--------------| -| manual_order_indic | Y | Y | Y | Y | Y | ~const,~null | -| order_type | Y | Y | N | Y | Y | ~const,~null | -| price | Y | Y | N | Y | Y | ~const,~null | -| quantity | Y | Y | N | Y | Y | ~const,~null | -| time | Y | Y | Y | Y | Y | ~const,~null | -| exchange_order_id | N | Y | Y | Y | N | const,null | -| avg_fill_price | N | N | N | Y | Y | ~const,null | -| filled_quantity | N | N | N | Y | Y | ~const,null | -| remaining_quantity | N | N | N | Y | Y | ~const,null | -| reject_msg | N | N | N | Y | Y | ~const,null | +| Field | create | update | cancel | recoverable | display | Lifecyle | +|--------------------+--------+--------+--------+-------------+---------+--------------| +| security | Y | Y | Y | Y | Y | const,~null | +| account | Y | Y | Y | Y | Y | const,~null | +| operatorid | Y | Y | Y | Y | Y | const,~null | +| orderkey | Y | Y | Y | Y | Y | const,~null | +| side | Y | Y | Y | Y | Y | const,~null | +| time_in_force | Y | Y | N | Y | Y | const,~null | +| customer_or_firm | Y | Y | N | N | Y | const,~null | +| cti_code | Y | Y | N | N | Y | const,~null | +| manual_order_indic | Y | Y | Y | Y | Y | const,~null | +| order_type | Y | Y | N | Y | Y | const,~null | +|--------------------+--------+--------+--------+-------------+---------+--------------| +| price | Y | Y | N | Y | Y | ~const,~null | +| quantity | Y | Y | N | Y | Y | ~const,~null | +| time | Y | Y | Y | Y | Y | ~const,~null | +| exchange_order_id | N | Y | Y | Y | Y | const,null | +| avg_fill_price | N | N | N | Y | Y | ~const,null | +| filled_quantity | N | N | N | Y | Y | ~const,null | +| remaining_quantity | N | N | N | Y | Y | ~const,null | +| reject_msg | N | N | N | Y | Y | ~const,null | +** OrderDefinition +Set by the user at creation time, unchangeable after that +| orderkey | +| parent_order_key | +| child_kind | +| security | +| account | +| operatorid | +| side | +| time_in_force | +| order_type | +| manual_order_indicator | +| customer_or_firm | +| cti_code | +** OrderParameters +Changeable by user, reported by exchange +| price | +| quantity | +** OrderUpdate +Reported by the exchange +| price | +| quantity | +| last_fill_price | +| avg_fill_price | +| filled_quantity | +| order_status | +| exchange_order_id | +| reject_msg | + +** OrderState +OrderDefinition + OrderParameters + (OrderUpdate) +** OrderCreation +OrderDefinition + OrderParameters +** OrderUpdate +orderkey + OrderParameters +** OrderCancel +orderkey * Order Chain trace ** NewOrder - =-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= +=-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= BeginString = FIX.4.2 8=FIX.4.2 BodyLength = 271 9=271 MsgType = NewOrderSingle 35=D @@ -69,7 +105,7 @@ SecurityExchange = GLBX 207=GLBX 7928 = 8056218 7928=8056218 9702 = 2 9702=2 CheckSum = 127 10=127 - =-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= +=-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= BeginString = FIX.4.2 8=FIX.4.2 BodyLength = 334 9=334 MsgType = ExecutionReport 35=8 @@ -108,7 +144,7 @@ ExpireDate = 20161102 432=20161102 7928 = 8056218 7928=8056218 CheckSum = 038 10=038 ** Cancel - =-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= +=-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= BeginString = FIX.4.2 8=FIX.4.2 BodyLength = 327 9=327 MsgType = OrderCancelRequest 35=F @@ -142,7 +178,7 @@ SecurityExchange = GLBX 207=GLBX 9702 = 2 9702=2 9717 = 2KjMkw-1C22h9-001v8Q 9717=2KjMkw-1C22h9-001v8Q CheckSum = 186 10=186 - =-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= +=-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= BeginString = FIX.4.2 8=FIX.4.2 BodyLength = 379 9=379 MsgType = ExecutionReport 35=8 @@ -182,7 +218,7 @@ ExpireDate = 20161102 432=20161102 9717 = 2KjMkw-1C22h9-001v8Q 9717=2KjMkw-1C22h9-001v8Q CheckSum = 033 10=033 ** Cancel/Replace - =-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= +=-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= BeginString = FIX.4.2 8=FIX.4.2 BodyLength = 344 9=344 MsgType = OrderCancelReplaceRequest 35=G @@ -219,7 +255,7 @@ SecurityExchange = GLBX 207=GLBX 9717 = 2KjMkw-1C22gp-001v8P 9717=2KjMkw-1C22gp-001v8P 9768 = Y 9768=Y CheckSum = 065 10=065 - =-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= +=-=-=-=-=-=-==-=-=-=-=-=-==-=-=-=-=-=-= BeginString = FIX.4.2 8=FIX.4.2 BodyLength = 379 9=379 MsgType = ExecutionReport 35=8 @@ -259,13 +295,6 @@ ExpireDate = 20161102 432=20161102 9717 = 2KjMkw-1C22gp-001v8P 9717=2KjMkw-1C22gp-001v8P CheckSum = 151 10=151 -* Order fields -- SenderSubID -- Account -- ClOrdID -- OrdType -- Side -- Security * Open Issues - Shell has ugly menus - Self match protection @@ -288,6 +317,8 @@ CheckSum = 151 10=151 - simpler wiring - less indirection in dispatch - consider passing lambdas around +* Reference +10.96.25.29 * Notes on "A guide to spread trading futures" - Spread trading exploits correlations between securities and mean reversion @@ -335,3 +366,5 @@ CheckSum = 151 10=151 + + diff --git a/src/server/sparkd/orderman/native_orders/NativeOrder.h b/src/server/sparkd/orderman/native_orders/NativeOrder.h index 5003cba45..d369012be 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrder.h +++ b/src/server/sparkd/orderman/native_orders/NativeOrder.h @@ -21,7 +21,7 @@ namespace orderman { class NativeOrderMan; class NativeOrder { -protected: +public: // orders can only be built by special factory classes friend class NativeOrderFactory; friend class NativeOrderBuilder; diff --git a/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp b/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp index 14578c156..da04181f4 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp +++ b/src/server/sparkd/orderman/native_orders/NativeOrderBuilder.cpp @@ -6,7 +6,7 @@ namespace bts { namespace orderman { -const auto order_batch_sz = 100; +const auto order_batch_sz = 10; struct NativeOrderBuilder::PImpl { diff --git a/src/server/sparkd/orderman/native_orders/NativeOrderFactory.cpp b/src/server/sparkd/orderman/native_orders/NativeOrderFactory.cpp index 8c1148644..b8e64ee1d 100644 --- a/src/server/sparkd/orderman/native_orders/NativeOrderFactory.cpp +++ b/src/server/sparkd/orderman/native_orders/NativeOrderFactory.cpp @@ -118,14 +118,21 @@ void NativeOrderFactory::refill(uint32_t at_least_these) void NativeOrderFactory::do_work() { - int64_t need_these = 0; + std::vector builders; + int64_t need_these = 0; { std::lock_guard l(me->lock); need_these = key_batch_size - me->free_order_ids.size(); + builders.reserve(me->builders.size()); + for (auto &b : me->builders) + builders.push_back(b.get()); } if (need_these > 0) refill(need_these); + + for(auto b : builders) + b->do_work(); } From 93af8949facc6ccc865526f681d858cf27cae151 Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 13 Nov 2017 09:24:54 -0500 Subject: [PATCH 19/29] Merged --- .vscode/c_cpp_properties.json | 4 +- .vscode/launch.json | 53 +- .vscode/tasks.json | 6 +- docker/linux | 2 +- .../GenericCollectionExtensions.cs | 3 +- src/client/spark/core/bus/IBus.cs | 4 + src/client/spark/core/bus/SingletonBus.cs | 77 +-- .../mspark/Algo/Exchange/GatewayAdapter.cs | 10 +- .../mspark/Algo/Exchange/IMarketDataSource.cs | 6 +- src/client/spark/mspark/Core/MDSource.cs | 5 +- src/client/spark/mspark/Core/SecurityMD.cs | 7 +- src/client/spark/mspark/Core/SparkBusData.cs | 26 +- src/client/spark/mspark/Core/SparkTags.cs | 6 +- .../mspark/Core/SyntheticSecurityMDHandle.cs | 4 +- src/client/spark/mspark/Core/TickUtils.cs | 28 +- .../spark/mspark/Ladder/LadderGridHost.cs | 4 +- src/client/spark/mspark/Ladder/LadderModel.cs | 2 +- src/client/spark/mspark/Ladder/LadderVM.cs | 2 +- src/client/spark/mspark/Ladder/LaderRender.cs | 8 +- src/client/spark/mspark/Ladder/OrderTypeVM.cs | 2 +- .../spark/mspark/Ladder/RecenterCountdown.cs | 4 +- .../mspark/MarketView/MarketViewModel.cs | 19 +- .../spark/mspark/MarketView/MarketViewRow.cs | 2 +- .../spark/mspark/MarketView/MarketViewVM.cs | 10 +- src/client/spark/mspark/Orders/IOrderBook.cs | 18 +- .../spark/mspark/Orders/OrderExtensions.cs | 2 +- .../spark/mspark/Orders/OrderTicketVM.cs | 2 +- .../Orders/Sim/OrderActivitySimulator.cs | 4 +- .../mspark/Orders/Sim/SimExchangeGateway.cs | 6 +- .../SecuritySelectorDialogVM.cs | 4 +- .../SecurityBrowser/SecuritySelectorVM.cs | 16 +- .../mspark/SecurityBrowser/SecuritySource.cs | 7 +- .../spark/mspark/Shell/Fills/FillsVM.cs | 18 +- .../Shell/LaunchMenu/LaunchMenuItemVM.cs | 6 +- src/client/spark/mspark/Shell/MarketModule.cs | 10 +- .../Shell/MenuItems/CancelOrdersMenuItem.cs | 4 +- .../spark/mspark/Shell/MenuItems/IMenuItem.cs | 6 +- .../mspark/Shell/MenuItems/LadderMenuItem.cs | 4 +- .../Shell/MenuItems/MarketViewMenuItem.cs | 4 +- .../mspark/Shell/MenuItems/MenuItemVM.cs | 18 +- .../ModifySecuritySelectionMenuItem.cs | 6 +- .../Shell/MenuItems/OrderTicketMenuItem.cs | 12 +- .../Shell/MenuItems/SpreadMatrixMenuItem.cs | 4 +- .../MenuItems/SyntheticCreateMenuItem.cs | 4 +- .../MenuItems/SyntheticStrategyMenuItem.cs | 4 +- .../Shell/MenuItems/TimeAndSalesMenuItem.cs | 6 +- .../mspark/Shell/OrderBook/OrderBookRowVM.cs | 6 +- .../mspark/Shell/OrderBook/OrderBookVM.cs | 2 +- .../Synthetic/SyntheticEditorModel.cs | 5 +- .../Shell/TimeAndSales/TimeAndSalesModel.cs | 14 +- .../Shell/TimeAndSales/TimeAndSalesVM.cs | 22 +- .../Shell/TimeAndSales/TimeAndSalesWindow.cs | 8 +- src/client/spark/mspark/Shell/TradesModule.cs | 8 +- src/client/spark/mspark/Utilities/BBOVM.cs | 8 +- .../spark/mspark/Utilities/ISecurityMDPump.cs | 15 +- .../mspark/Utilities/ImportedResources.cs | 10 +- .../spark/mspark/Utilities/OrderDataHelper.cs | 6 +- .../mspark/Utilities/SecurityDataHelper.cs | 8 +- .../mspark/Utilities/SyntheticDataHelper.cs | 18 +- src/client/spark/sys/api/SecurityConverter.cs | 2 +- src/client/spark/sys/api/Test/ApiTests.cs | 2 +- .../spark/sys/api/Test/HelloServiceServer.cs | 4 +- src/client/spark/sys/persist/UISettings.cs | 8 +- .../uicore/Settings/UserPersistFactory.cs | 4 +- .../spark/uicore/Shell/Login/LoginModel.cs | 8 +- .../view/Controls/PriceEntryControl.xaml.cs | 10 +- .../SecurityCollectionView.cs | 4 +- .../SecuritySelectorControl/SecurityItem.cs | 8 +- .../SecuritySelectorControl.xaml.cs | 33 +- .../view/Converters/TickDisplayConverter.cs | 8 +- .../api/Channels/QuickBusClientChannel.cs | 12 +- src/client/spark_api/api/ClientChannel.cs | 30 +- src/client/spark_api/api/Result.cs | 82 +-- src/client/spark_api/api/Update.cs | 176 +++--- src/client/spark_api/security/Security.cs | 38 +- .../spark_api/security/SecurityFormatter.cs | 24 +- .../spark_api/security/SecurityHelper.cs | 16 +- ...ImmutableProto.cs => IImmutableMessage.cs} | 2 +- src/client/sparkcmd/Program.cs | 12 +- src/client/sparkcmd/sparkcmd.csproj | 2 +- src/lib/CMakeDeps.cmake | 2 +- src/lib/CMakeLists.txt | 1 + src/lib/api/service_compiler/plugin.py | 14 +- .../templates/c#/client.pb.cs | 21 +- .../templates/c#/immutable.pb.cs | 19 +- src/lib/api/services/AccountService.proto | 50 ++ src/lib/api/services/UserService.proto | 54 +- src/lib/config/defaults/Account.conf | 64 --- src/lib/config/defaults/User.conf | 25 - src/lib/config/protos/Account.proto | 34 -- src/lib/config/protos/User.proto | 27 - src/lib/sparkproto/SparkProtos.proto | 26 +- src/server/sparkd/CMakeDeps.cmake | 2 +- src/server/sparkd/CMakeLists.txt | 4 +- src/server/sparkd/cmds/Run.cpp | 2 + .../sparkd/orderman/components/Gateway.cpp | 5 +- .../spreader_orders/ISpreaderStateWorker.h | 6 +- .../spreader_orders/SpreaderOrder.cpp | 364 ++++--------- .../orderman/spreader_orders/SpreaderOrder.h | 97 ++-- .../spreader_orders/SpreaderOrderBase.cpp | 2 + .../spreader_orders/SpreaderOrderBase.h | 5 +- .../SpreaderEndStateWorker.cpp | 13 +- .../spreader_states/SpreaderEndStateWorker.h | 4 +- .../SpreaderStartStateWorker.cpp | 32 +- .../SpreaderStartStateWorker.h | 8 +- .../spreader_states/SpreaderState.h | 18 + ...SpreaderWaitingForCancelAllStateWorker.cpp | 38 +- .../SpreaderWaitingForCancelAllStateWorker.h | 4 +- ...SpreaderWaitingForFirstConnStateWorker.cpp | 128 ++++- .../SpreaderWaitingForFirstConnStateWorker.h | 16 +- .../SpreaderWorkingStateWorker.cpp | 94 ++-- .../SpreaderWorkingStateWorker.h | 4 +- .../orderman/tests/spreader_order_tests.cpp | 10 +- .../sparkd/risk_limits/RiskLimitManager.cpp | 98 ++-- .../sparkd/risk_limits/RiskLimitManager.h | 21 +- src/server/sparkd/risk_limits/RiskLimiter.cpp | 7 +- src/server/sparkd/risk_limits/RiskLimiter.h | 3 +- .../sparkd/risk_limits/SharedRiskLimiter.cpp | 19 +- .../sparkd/risk_limits/SharedRiskLimiter.h | 39 +- src/server/sparkd/risk_limits/SymbolKey.h | 2 +- .../risk_limits/tests/RiskLimitsTests.cpp | 79 ++- src/server/sparkd/spreader/LegPropertyData.h | 2 +- .../spreader/QuoteLegPriceQuantityState.cpp | 52 -- .../spreader/QuoteLegPriceQuantityState.h | 62 ++- .../sparkd/spreader/SingleLegQuoter.cpp | 506 +++--------------- src/server/sparkd/spreader/SingleLegQuoter.h | 143 +---- .../sparkd/spreader/SpreaderBookkeepingData.h | 32 +- src/server/sparkd/spreader/SpreaderLegData.h | 29 +- .../spreader/SpreaderOrderUpdateMessage.h | 1 + src/server/sparkd/spreader/SpreaderUtils.h | 52 +- .../spreader/quoter/IQuoterStateWorker.h | 8 +- .../quoter_states/QuoterEndStateWorker.cpp | 11 +- .../quoter_states/QuoterEndStateWorker.h | 9 +- .../quoter_states/QuoterStartStateWorker.cpp | 30 +- .../quoter_states/QuoterStartStateWorker.h | 10 +- ...terWaitingForCancelAckFinalStateWorker.cpp | 40 +- ...uoterWaitingForCancelAckFinalStateWorker.h | 9 +- ...erWaitingForCancelAckReturnStateWorker.cpp | 53 +- ...oterWaitingForCancelAckReturnStateWorker.h | 11 +- ...uoterWaitingForFirstAckCancelledWorker.cpp | 42 +- .../QuoterWaitingForFirstAckCancelledWorker.h | 10 +- .../QuoterWaitingForFirstAckWorker.cpp | 48 +- .../QuoterWaitingForFirstAckWorker.h | 13 +- .../QuoterWaitingForSizeStateWorker.cpp | 62 +-- .../QuoterWaitingForSizeStateWorker.h | 18 +- .../QuoterWorkingStateWorker.cpp | 97 +++- .../quoter_states/QuoterWorkingStateWorker.h | 14 +- .../sparkd/user/AccountServiceServer.cpp | 187 +++++++ src/server/sparkd/user/AccountServiceServer.h | 35 ++ src/server/sparkd/user/UserServiceServer.cpp | 244 ++++++++- src/server/sparkd/user/UserServiceServer.h | 28 +- .../sparkd/user/tests/UserAndAccountTests.cpp | 275 ++++++++++ tools/buildsparkd.cmd | 4 +- tools/replicator/replicate_to_linux_vm.py | 4 +- tools/runsparkd.cmd | 3 +- tools/vscode.cmd | 6 + 156 files changed, 2571 insertions(+), 2114 deletions(-) rename src/client/spark_api/utils/{IImmutableProto.cs => IImmutableMessage.cs} (94%) create mode 100644 src/lib/api/services/AccountService.proto delete mode 100644 src/lib/config/defaults/Account.conf delete mode 100644 src/lib/config/defaults/User.conf delete mode 100644 src/lib/config/protos/Account.proto delete mode 100644 src/lib/config/protos/User.proto create mode 100644 src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h delete mode 100644 src/server/sparkd/spreader/QuoteLegPriceQuantityState.cpp create mode 100644 src/server/sparkd/user/AccountServiceServer.cpp create mode 100644 src/server/sparkd/user/AccountServiceServer.h create mode 100644 src/server/sparkd/user/tests/UserAndAccountTests.cpp create mode 100644 tools/vscode.cmd diff --git a/.vscode/c_cpp_properties.json b/.vscode/c_cpp_properties.json index 161d4cb09..d87bf5a95 100644 --- a/.vscode/c_cpp_properties.json +++ b/.vscode/c_cpp_properties.json @@ -25,7 +25,7 @@ "includePath": [ "${workspaceRoot}/src", "${workspaceRoot}/build/src", - "${workspaceRoot}/build/gcc_debug/src", + "${workspaceRoot}/build/ninja_debug/src", "${workspaceRoot}/externals/windows/include", "${workspaceRoot}/externals/linux/include", "${workspaceRoot}/externals/windows/vscode/usr/include/c++/6", @@ -45,7 +45,7 @@ "path": [ "${workspaceRoot}/src", "${workspaceRoot}/build/src", - "${workspaceRoot}/build/gcc_debug/src", + "${workspaceRoot}/build/ninja_debug/src", "${workspaceRoot}/externals/windows/include", "${workspaceRoot}/externals/linux/include", "${workspaceRoot}/externals/windows/vscode/usr/include/c++/6", diff --git a/.vscode/launch.json b/.vscode/launch.json index 35c9b4ca7..4838001e2 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -5,10 +5,10 @@ "name": "(gdb) Launch", "type": "cppdbg", "request": "launch", - "program": "${workspaceRoot}/build/gcc_debug/src/server/sparkd/sparkd", + "program": "${workspaceRoot}/build/ninja_debug/src/server/sparkd/sparkd", "args": ["run"], "stopAtEntry": false, - "cwd": "${workspaceRoot}/build/gcc_debug/src/server/sparkd", + "cwd": "${workspaceRoot}/build/ninja_debug/src/server/sparkd", "environment": [], "externalConsole": true, "MIMode": "gdb", @@ -41,8 +41,8 @@ "type": "cppdbg", "request": "launch", "program": "/home/bts/spark/build/ninja_debug/src/server/sparkd/sparkd", - "args": ["configcheck", "System"], - "stopAtEntry": true, + "args": ["test", "[risklimits]"], + "stopAtEntry": false, "cwd": "/home/bts/spark/build/ninja_debug/src/server/sparkd/", "environment": [], "externalConsole": true, @@ -68,50 +68,21 @@ "/home/bts/spark/": "${workspaceRoot}" } }, - { - "name": "Docker Launch", - "type": "cppdbg", - "request": "launch", - "program": "/bts/build/gcc_debug/src/server/sparkd/sparkd", - "args": ["test"], - "stopAtEntry": false, - "cwd": "/bts/build/gcc_debug/src/server/sparkd", - "environment": [], - "externalConsole": true, - "MIMode": "gdb", - "preLaunchTask": "", - "setupCommands": [ - { - "description": "Enable pretty-printing for gdb", - "text": "enable pretty-printer", - "ignoreFailures": true - } - ], - "pipeTransport": { - "pipeCwd": "${workspaceRoot}", - "pipeProgram": "c:\\program files\\git\\usr\\bin\\ssh.exe", - "pipeArgs": ["-p 2000","root@localhost"], - "debuggerPath": "/usr/bin/gdb" - }, - "sourceFileMap": { - "/bts/": "${workspaceRoot}" - } - }, - { - "name": "Docker attach", + { + "name": "SparkVM attach", "type": "cppdbg", "request": "attach", - "program": "/bts/build/gcc_debug/src/server/sparkd/sparkd", + "program": "/home/bts/spark/build/ninja_debug/src/server/sparkd/sparkd", "processId": "${command:pickRemoteProcess}", "MIMode": "gdb", "pipeTransport": { - "pipeCwd": "${workspaceRoot}", - "pipeProgram": "c:\\program files\\git\\usr\\bin\\ssh.exe", - "pipeArgs": ["-p 2000","root@localhost"], - "debuggerPath": "/usr/bin/gdb" + "pipeCwd": "${workspaceRoot}", + "pipeProgram": "c:\\program files\\git\\usr\\bin\\ssh.exe", + "pipeArgs": ["bts@sparkvm"], + "debuggerPath": "/usr/bin/gdb" }, "sourceFileMap": { - "/bts/": "${workspaceRoot}" + "/home/bts/spark/": "${workspaceRoot}" } }, { diff --git a/.vscode/tasks.json b/.vscode/tasks.json index 0a8aebedb..4d59332ac 100644 --- a/.vscode/tasks.json +++ b/.vscode/tasks.json @@ -6,7 +6,7 @@ { "taskName": "client_build", "type": "shell", - "command": ".\\tools\\clientbuild.cmd", + "command": ".\\tools\\buildspark.cmd", "problemMatcher":"$msCompile", "presentation": { "echo": true, @@ -22,7 +22,7 @@ { "taskName": "server_build", "type": "shell", - "command": ".\\tools\\ssh_serverbuild.cmd", + "command": ".\\tools\\buildsparkd.cmd", "problemMatcher": { "base": "$gcc", @@ -32,7 +32,7 @@ "echo": true, "reveal": "always", "focus": false, - "panel": "shared" + "panel": "new" }, "group": { "kind": "build", diff --git a/docker/linux b/docker/linux index 41523ccab..d4a32d325 160000 --- a/docker/linux +++ b/docker/linux @@ -1 +1 @@ -Subproject commit 41523ccab74b95bb007d9b9330d52c0f9e12dd1e +Subproject commit d4a32d32592c688c3a1f042750fd3323bcdfd38a diff --git a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs index 6f8441e4e..a9b506ddb 100644 --- a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs +++ b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs @@ -128,6 +128,7 @@ namespace System.Collections.ObjectModel public static class ObservableCollectionExtensions { public static int RemoveAll(this ObservableCollection collection, Func match) { + if (collection == null) return 0; // In terms of allocations we could do this more efficiently by copying items from the end of the // collection in (see https://referencesource.microsoft.com/#q=RemoveAll) but that would allow // transient duplication in the list which could be observed from the outside @@ -218,7 +219,7 @@ namespace mbts.collections.extensions public static class DictionaryExtensions { #region GetValueOrDefault - public static TValue GetValueOrDefault(this Dictionary dictionary, TKey key) { + public static TValue GetValueOrDefault(this IReadOnlyDictionary dictionary, TKey key) { return dictionary.TryGetValue(key, out TValue result) ? result : default(TValue); } diff --git a/src/client/spark/core/bus/IBus.cs b/src/client/spark/core/bus/IBus.cs index 5983f33f2..2146d24b4 100644 --- a/src/client/spark/core/bus/IBus.cs +++ b/src/client/spark/core/bus/IBus.cs @@ -7,14 +7,18 @@ using System.Threading.Tasks; namespace bts.api { public interface ITag { } + // It is important that ITag is a distinct type from ITag + public interface ITag { } public interface ISubscribe { IObservable subscribe(ITag tag); + IObservable subscribe(ITag tag); } public interface IPost { void post(ITag tag, T data); + void post(ITag tag, T data); } public interface IBus : IPost, ISubscribe diff --git a/src/client/spark/core/bus/SingletonBus.cs b/src/client/spark/core/bus/SingletonBus.cs index 4c37ab31f..fb21dd220 100644 --- a/src/client/spark/core/bus/SingletonBus.cs +++ b/src/client/spark/core/bus/SingletonBus.cs @@ -1,37 +1,44 @@ -using bts.api; +using bts.api; using mbts.utils; -using System; -using System.Collections.Generic; -using System.ComponentModel.Composition; -using System.Reactive.Subjects; - -namespace bts.core -{ - [Export(typeof(IBus))] - public class SingletonBus : IBus { - - private class SubjectSingleton { - public static Dictionary> instance = new Dictionary>(); - } - - private ISubject subject(ITag tag) { - var inst = SubjectSingleton.instance; - lock (inst) { - if (inst.TryGetValue(tag, out ISubject result)) { - return result; - } - result = new StateSubject(); - inst[tag] = result; - return result; - } - } - - public void post(ITag tag, T data) { - subject(tag).OnNext(data); - } - - public IObservable subscribe(ITag tag) { - return subject(tag); - } - } +using System; +using System.Collections.Generic; +using System.ComponentModel.Composition; +using System.Reactive.Subjects; + +namespace bts.core +{ + [Export(typeof(IBus))] + public class SingletonBus : IBus { + + private class SubjectSingleton { + public static Dictionary> instance = new Dictionary>(); + } + + private ISubject subject(object tag) { + var inst = SubjectSingleton.instance; + lock (inst) { + if (inst.TryGetValue(tag, out ISubject result)) { + return result; + } + result = new Subject(); + inst[tag] = result; + return result; + } + } + + public void post(ITag tag, T data) { + subject(tag).OnNext(data); + } + public void post(ITag tag, T data) { + subject(tag).OnNext(data); + } + + public IObservable subscribe(ITag tag) { + return subject(tag); + } + + public IObservable subscribe(ITag tag) { + return subject(tag); + } + } } \ No newline at end of file diff --git a/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs b/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs index 22513e81b..4a7479ce5 100644 --- a/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs +++ b/src/client/spark/mspark/Algo/Exchange/GatewayAdapter.cs @@ -25,7 +25,7 @@ namespace mbts.spark class GatewayAdapter : IMarketDataSource, IDropCopy, IPollable { SimExchangeGateway _gw; - IDictionary _cache; + IReadOnlyDictionary _cache; object _lock = new object(); ConcurrentBag>> _bbo = new ConcurrentBag>>(); @@ -61,8 +61,8 @@ namespace mbts.spark } } - public IObservable> - subscribe_bbo(bts.api.Security security) + public IObservable> + subscribe_bbo(bts.api.SecurityImmutable security) { lock(_cache) { @@ -77,8 +77,8 @@ namespace mbts.spark } } - public IObservable> - subscribe_depth(bts.api.Security security) + public IObservable> + subscribe_depth(bts.api.SecurityImmutable security) { lock(_cache) { diff --git a/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs b/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs index ce6d89f26..b1c4d010d 100644 --- a/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs +++ b/src/client/spark/mspark/Algo/Exchange/IMarketDataSource.cs @@ -6,9 +6,9 @@ using mbts.co2; namespace mbts.spark { - public interface IMarketDataSource + interface IMarketDataSource { - IObservable> subscribe_bbo(Security security); - IObservable> subscribe_depth(Security security); + IObservable> subscribe_bbo(SecurityImmutable security); + IObservable> subscribe_depth(SecurityImmutable security); } } \ No newline at end of file diff --git a/src/client/spark/mspark/Core/MDSource.cs b/src/client/spark/mspark/Core/MDSource.cs index 2fe22f22f..9ab5fa1de 100644 --- a/src/client/spark/mspark/Core/MDSource.cs +++ b/src/client/spark/mspark/Core/MDSource.cs @@ -27,7 +27,6 @@ namespace mbts.spark { _bus = bus; _consumer = Co2RelayControl.instance.consumer; - new OrderHub(bus, username); } public void OnCompleted() { } @@ -45,7 +44,6 @@ namespace mbts.spark temp.Add(v.security.Id, new SecurityMD(v.security, v.handle)); } _exchange_sec_map = temp; - //_publish_securities(); } } @@ -83,7 +81,6 @@ namespace mbts.spark if (synth_secs != null && synth_secs.data != null) { _synthetic_sec_map = synth_secs.data.ToDictionaryDupes(s => s.Key, s => new SecurityMD(s.Value.Security, new SyntheticSecurityMDHandle(s.Value.Security, _exchange_sec_map))); - //_publish_securities(); } } @@ -92,7 +89,7 @@ namespace mbts.spark var rv = new Dictionary(_exchange_sec_map); foreach (var kv in _synthetic_sec_map) { - Security sec = kv.Value.security; + var sec = kv.Value.security; rv.Add(sec.Id, new SecurityMD(sec, new SyntheticSecurityMDHandle(sec, _exchange_sec_map))); } Logger.log(bts.log.Level.Info, bts.log.Subsystem.gen, String.Format("MDSource publishing {0} securities", rv.Count)); diff --git a/src/client/spark/mspark/Core/SecurityMD.cs b/src/client/spark/mspark/Core/SecurityMD.cs index 34cc7e004..78295830c 100644 --- a/src/client/spark/mspark/Core/SecurityMD.cs +++ b/src/client/spark/mspark/Core/SecurityMD.cs @@ -1,4 +1,5 @@ -using mbts.co2; +using bts.api; +using mbts.co2; using System; using System.Collections.Generic; using System.Linq; @@ -9,10 +10,10 @@ namespace mbts.spark { struct SecurityMD { - public bts.api.Security security { get; } + public SecurityImmutable security { get; } public IMDHandle md { get; } - public SecurityMD(bts.api.Security security, IMDHandle md) { + public SecurityMD(SecurityImmutable security, IMDHandle md) { this.security = security; this.md = md; } diff --git a/src/client/spark/mspark/Core/SparkBusData.cs b/src/client/spark/mspark/Core/SparkBusData.cs index fcfb650c6..a5b088387 100644 --- a/src/client/spark/mspark/Core/SparkBusData.cs +++ b/src/client/spark/mspark/Core/SparkBusData.cs @@ -50,15 +50,15 @@ namespace mbts.spark } public class ShowAuditLogsMessage { } public class ShowFillsMessage { } - public class ShowLadderMessage : BusMessageWrapper> { - public ShowLadderMessage(Security security) : this(new[] { security }) { } - public ShowLadderMessage(IReadOnlyCollection security) : base(security) { } + public class ShowLadderMessage : BusMessageWrapper> { + public ShowLadderMessage(SecurityImmutable security) : this(new[] { security }) { } + public ShowLadderMessage(IReadOnlyCollection security) : base(security) { } } public class ShowLinkedLadderMessage : BusMessageWrapper> { public ShowLinkedLadderMessage(IObservable security_md) : base(security_md) { } } - public class ShowMarketViewMessage : BusMessageWrapper> { - public ShowMarketViewMessage(IReadOnlyCollection securities) : base(securities) { } + public class ShowMarketViewMessage : BusMessageWrapper> { + public ShowMarketViewMessage(IReadOnlyCollection securities) : base(securities) { } } public class ShowOrderBookMessage { } public class ShowOrderModifyMessage : BusMessageWrapper> { @@ -73,17 +73,17 @@ namespace mbts.spark public ShowLinkedOrderTicketMessage(IObservable order) : base(order) { } } public class ShowPositionsMessage { } - public class ShowSpreadMatrixMessage : BusMessageWrapper> { - public ShowSpreadMatrixMessage(IReadOnlyCollection securities) : base(securities) { } + public class ShowSpreadMatrixMessage : BusMessageWrapper> { + public ShowSpreadMatrixMessage(IReadOnlyCollection securities) : base(securities) { } } - public class ShowSyntheticCreateMessage : BusMessageWrapper> { - public ShowSyntheticCreateMessage(IReadOnlyCollection securities) : base(securities) { } + public class ShowSyntheticCreateMessage : BusMessageWrapper> { + public ShowSyntheticCreateMessage(IReadOnlyCollection securities) : base(securities) { } } - public class ShowSyntheticStrategyMessage : BusMessageWrapper { - public ShowSyntheticStrategyMessage(Security security) : base(security) { } + public class ShowSyntheticStrategyMessage : BusMessageWrapper { + public ShowSyntheticStrategyMessage(SecurityImmutable security) : base(security) { } } - public class ShowTimeAndSalesMessage : BusMessageWrapper> { - public ShowTimeAndSalesMessage(IReadOnlyCollection security) : base(security) { } + public class ShowTimeAndSalesMessage : BusMessageWrapper> { + public ShowTimeAndSalesMessage(IReadOnlyCollection security) : base(security) { } } public class PositionsMessage : BusMessageWrapper> { diff --git a/src/client/spark/mspark/Core/SparkTags.cs b/src/client/spark/mspark/Core/SparkTags.cs index 6e705e902..fa75b6259 100644 --- a/src/client/spark/mspark/Core/SparkTags.cs +++ b/src/client/spark/mspark/Core/SparkTags.cs @@ -1,12 +1,14 @@ using bts.api; +using System.Collections.Generic; namespace mbts.spark { - public static class SparkTags { + static class SparkTags { private class SparkTag : ITag { private readonly string Name; public SparkTag(string name) { Name = name; } } + private class SparkTag : ITag { private readonly string Name; public SparkTag(string name) { Name = name; } } #region Core Data public static ITag ExchangeSecuritiesTag { get; } = new SparkTag("ExchangeSecuritiesTag"); - public static ITag SecuritiesTag { get; } = new SparkTag("Securities"); + public static ITag> SecuritiesTag { get; } = new SparkTag>("Securities"); public static ITag SyntheticSecuritiesTag { get; } = new SparkTag("SyntheticSecuritiesTag"); public static ITag OrderBookTag = new SparkTag("OrderBookTag"); public static ITag PositionsTag { get; } = new SparkTag(nameof(PositionsTag)); diff --git a/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs b/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs index 02258abd6..92a569c65 100644 --- a/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs +++ b/src/client/spark/mspark/Core/SyntheticSecurityMDHandle.cs @@ -71,10 +71,10 @@ namespace mbts.spark public uint normalized_head_size { get { return active ? levels[0].qty : 0; } } } - private readonly Security _security; + private readonly SecurityImmutable _security; private IEnumerable> _legs; private const uint _default_book_size = 10; - public SyntheticSecurityMDHandle(Security security, IDictionary md_handles) + public SyntheticSecurityMDHandle(SecurityImmutable security, IDictionary md_handles) { _security = security; _legs = security.get_base_exchange_securities().Select(t => diff --git a/src/client/spark/mspark/Core/TickUtils.cs b/src/client/spark/mspark/Core/TickUtils.cs index ce0acbe32..55f58de6a 100644 --- a/src/client/spark/mspark/Core/TickUtils.cs +++ b/src/client/spark/mspark/Core/TickUtils.cs @@ -7,23 +7,23 @@ using System.Collections.ObjectModel; using System.Linq; namespace mbts.spark { - public static class TickUtils { - public static readonly ContractSpecification DefaultSpec = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; - public static double ticksize(this ContractSpecification spec, double price) { + static class TickUtils { + public static readonly ContractSpecificationImmutable DefaultSpec = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; + public static double ticksize(this ContractSpecificationImmutable spec, double price) { return Math.Abs(price) > spec.PriceBreak ? spec.HighTick : spec.LowTick; } - public static string format(this ContractSpecification spec, double price) { + public static string format(this ContractSpecificationImmutable spec, double price) { var tick_factors = _get_tick_factors(spec.ticksize(price)); return tick_factors.format(price, false); } - public static double parse(this ContractSpecification spec, string text) { + public static double parse(this ContractSpecificationImmutable spec, string text) { var regional_tfs = new RegionalTickFactors { low_tick = _get_tick_factors(spec.LowTick), high_tick = _get_tick_factors(spec.HighTick), low_tick_inclusive_end = spec.PriceBreak }; return regional_tfs.parse(text); } - public static double mid_tick(ContractSpecification spec, double bid, double ask) { + public static double mid_tick(ContractSpecificationImmutable spec, double bid, double ask) { double raw_mid; if (double.IsNaN(bid)) { raw_mid = ask; } else if (double.IsNaN(ask)) { raw_mid = bid; } @@ -35,12 +35,12 @@ namespace mbts.spark { } - public static double tickup(this ContractSpecification contract, double value) { return get_regional_ticks(contract).tickup(value); } - public static double tickup(this ContractSpecification contract, double value, int count) { return get_regional_ticks(contract).tickup(value, (uint)count); } - public static double tickdown(this ContractSpecification contract, double value) { return get_regional_ticks(contract).tickdown(value); } - public static double tickdown(this ContractSpecification contract, double value, int count) { return get_regional_ticks(contract).tickdown(value, (uint)count); } + public static double tickup(this ContractSpecificationImmutable contract, double value) { return get_regional_ticks(contract).tickup(value); } + public static double tickup(this ContractSpecificationImmutable contract, double value, int count) { return get_regional_ticks(contract).tickup(value, (uint)count); } + public static double tickdown(this ContractSpecificationImmutable contract, double value) { return get_regional_ticks(contract).tickdown(value); } + public static double tickdown(this ContractSpecificationImmutable contract, double value, int count) { return get_regional_ticks(contract).tickdown(value, (uint)count); } - public static double round_to_tick(this ContractSpecification spec, double value) { + public static double round_to_tick(this ContractSpecificationImmutable spec, double value) { double intpart = (long)value; double floatpart = value % 1; double tick = spec.ticksize(value); @@ -48,7 +48,7 @@ namespace mbts.spark { return intpart + floatpart; } - public static int ticks_between(double a, double b, ContractSpecification spec) { + public static int ticks_between(double a, double b, ContractSpecificationImmutable spec) { double low = Math.Min(a, b); double high = Math.Max(a, b); int count = 0; @@ -59,10 +59,10 @@ namespace mbts.spark { return count; } - public static int[] get_tick_jump_quantities(ContractSpecification spec) { + public static int[] get_tick_jump_quantities(ContractSpecificationImmutable spec) { return _ticks_cache.TryGetValue(spec.LowTick, out (TickFactors tf, int[] jumps) result) ? result.jumps : new[] { 1, 5, 10, 25, 50, 100 }; } - public static RegionalTickFactors get_regional_ticks(ContractSpecification spec) { + public static RegionalTickFactors get_regional_ticks(ContractSpecificationImmutable spec) { return _regional_ticks_cache.GetOrAdd((spec.LowTick, spec.HighTick, spec.PriceBreak), _create_regional_ticks); } private static RegionalTickFactors _create_regional_ticks((double low_tick, double high_tick, double price_break) def) { diff --git a/src/client/spark/mspark/Ladder/LadderGridHost.cs b/src/client/spark/mspark/Ladder/LadderGridHost.cs index a168f6fee..cf481b24e 100644 --- a/src/client/spark/mspark/Ladder/LadderGridHost.cs +++ b/src/client/spark/mspark/Ladder/LadderGridHost.cs @@ -23,7 +23,7 @@ namespace mbts.spark { IDisposable _settings_sub, _tick_sub; LadderSettings _settings; LadderVM _vm; - ContractSpecification _spec; + ContractSpecificationImmutable _spec; VisualHost _visualHost = new VisualHost() {}; LadderOrdersHost _ordershost; @@ -55,7 +55,7 @@ namespace mbts.spark { public event Action click; - public Security security => _vm.security; + public SecurityImmutable security => _vm.security; public ICommand RecenterCommand { get; } public ICommand Command { diff --git a/src/client/spark/mspark/Ladder/LadderModel.cs b/src/client/spark/mspark/Ladder/LadderModel.cs index 3ff7b1cc8..f36504873 100644 --- a/src/client/spark/mspark/Ladder/LadderModel.cs +++ b/src/client/spark/mspark/Ladder/LadderModel.cs @@ -22,7 +22,7 @@ namespace mbts.spark { _order_gateway = ordergw; } - public Security security { get; } + public SecurityImmutable security { get; } public IMDHandle md { get; } public enum CancelType { All, Bids, Asks } diff --git a/src/client/spark/mspark/Ladder/LadderVM.cs b/src/client/spark/mspark/Ladder/LadderVM.cs index 8defb25a0..9d1f15235 100644 --- a/src/client/spark/mspark/Ladder/LadderVM.cs +++ b/src/client/spark/mspark/Ladder/LadderVM.cs @@ -68,7 +68,7 @@ namespace mbts.spark { } internal LadderModel model => _model; - public Security security => _model.security; + public SecurityImmutable security => _model.security; public IMDHandle md => _model.md; public bool is_synthetic => _model.security.ContractCase == Security.ContractOneofCase.Synthetic; diff --git a/src/client/spark/mspark/Ladder/LaderRender.cs b/src/client/spark/mspark/Ladder/LaderRender.cs index ef1bcda38..0c5e07e8a 100644 --- a/src/client/spark/mspark/Ladder/LaderRender.cs +++ b/src/client/spark/mspark/Ladder/LaderRender.cs @@ -30,7 +30,7 @@ namespace mbts.spark { #pragma warning restore CS0618 // Type or member is obsolete } - public static double[] gen_prices(double mid, int row_count, ContractSpecification spec) { + public static double[] gen_prices(double mid, int row_count, ContractSpecificationImmutable spec) { // require odd number Logger.assert(row_count % 2 == 1); var result = new double[row_count]; @@ -48,7 +48,7 @@ namespace mbts.spark { return result; } - public static FormattedText[] format_prices(double[] prices, string font_family, double font_size, SolidColorBrush foreground, ContractSpecification spec) { + public static FormattedText[] format_prices(double[] prices, string font_family, double font_size, SolidColorBrush foreground, ContractSpecificationImmutable spec) { var result = new FormattedText[prices.Length]; var font = new Typeface(font_family); Parallel.For(0, prices.Length, i => { @@ -64,7 +64,7 @@ namespace mbts.spark { } public static double[] render_prices(DrawingVisual price, double mid, int row_count, double row_height, - LadderColumnSettings settings, ContractSpecification spec) { + LadderColumnSettings settings, ContractSpecificationImmutable spec) { var foreground = new SolidColorBrush(settings.foreground.rgb_color()); var background = new SolidColorBrush(settings.background.rgb_color()); var dprices = gen_prices(mid, row_count, spec); @@ -107,7 +107,7 @@ namespace mbts.spark { double[] prices, NativePriceSize[] rungs, double row_height, - ContractSpecification spec, + ContractSpecificationImmutable spec, LadderColumnSettings settings ) { if (rungs.Length > 1) { diff --git a/src/client/spark/mspark/Ladder/OrderTypeVM.cs b/src/client/spark/mspark/Ladder/OrderTypeVM.cs index 14cba9453..fc41a32e2 100644 --- a/src/client/spark/mspark/Ladder/OrderTypeVM.cs +++ b/src/client/spark/mspark/Ladder/OrderTypeVM.cs @@ -23,7 +23,7 @@ namespace mbts.spark { is_bts_type = order.Descriptor.Name.StartsWith("BTS", StringComparison.CurrentCultureIgnoreCase); algo_type = OrderDataHelper.get_algo_type(order); _accessor = Order.Descriptor.Oneofs - .First(ood => ood.Name == "algo_order_type") + .First(ood => ood.Name == "AlgoOrderType") .Fields .First(f => f.MessageType == order.Descriptor) .Accessor; diff --git a/src/client/spark/mspark/Ladder/RecenterCountdown.cs b/src/client/spark/mspark/Ladder/RecenterCountdown.cs index f4131ec61..a7123afcb 100644 --- a/src/client/spark/mspark/Ladder/RecenterCountdown.cs +++ b/src/client/spark/mspark/Ladder/RecenterCountdown.cs @@ -15,7 +15,7 @@ namespace mbts.spark { DispatcherTimer _timer = new DispatcherTimer(DispatcherPriority.Background) { Interval = TimeSpan.FromSeconds(1) }; - Security _security; + SecurityImmutable _security; IMDHandle _handle; LadderSettings _settings; DateTime _last_recenter = DateTime.MaxValue; @@ -29,7 +29,7 @@ namespace mbts.spark { _timer.Start(); } - static (double,double) tick_range(double price, int tick_count, ContractSpecification spec) { + static (double,double) tick_range(double price, int tick_count, ContractSpecificationImmutable spec) { return (TickUtils.tickdown(spec, price, tick_count), TickUtils.tickup(spec, price, tick_count)); } diff --git a/src/client/spark/mspark/MarketView/MarketViewModel.cs b/src/client/spark/mspark/MarketView/MarketViewModel.cs index 1432aa998..6b469bfdc 100644 --- a/src/client/spark/mspark/MarketView/MarketViewModel.cs +++ b/src/client/spark/mspark/MarketView/MarketViewModel.cs @@ -8,8 +8,7 @@ using System.Reactive.Linq; using System.Reactive.Subjects; using static mbts.spark.SparkBusData; using static mbts.spark.SparkTags; -using MDMap = System.Collections.Generic.Dictionary; -using SecurityKey = System.UInt32; +using security_key = System.UInt32; namespace mbts.spark { @@ -25,20 +24,20 @@ namespace mbts.spark private readonly IBus _bus; private readonly OrdersModel _orders_model; - private readonly Subject> _securities_subject = new Subject>(); - private readonly ObservableDemuxer _positions_demuxer = new ObservableDemuxer(k => 0); + private readonly Subject> _securities_subject = new Subject>(); + private readonly ObservableDemuxer _positions_demuxer = new ObservableDemuxer(k => 0); private IList _subs = new List(); - private IDictionary _data = new Dictionary(); + private IDictionary _data = new Dictionary(); - public IObservable> rows => _bus.subscribe(SecuritiesTag).StartWith(new MDMap()).CombineLatest(_securities_subject, (md, secs) => md.Intersect(secs, kv => kv.Key).Select(kv => kv.Value)); - public IReadOnlyCollection all_securities => _data.Values.Select(s => s.security).ToList(); + public IObservable> rows => _bus.subscribe(SecuritiesTag).StartWith(new Dictionary()).CombineLatest(_securities_subject, (md, secs) => md.Intersect(secs, kv => kv.Key).Select(kv => kv.Value)); + public IReadOnlyCollection all_securities => _data.Values.Select(s => s.security).ToList(); public OrdersModel orders_model => _orders_model; - public IObservable security_position(SecurityKey key) { return _positions_demuxer.subscribe(key).DistinctUntilChanged(); } - public void show_ladder(Security security) { _bus.post(ShowLadderTag, new ShowLadderMessage(security)); } + public IObservable security_position(security_key key) { return _positions_demuxer.subscribe(key).DistinctUntilChanged(); } + public void show_ladder(SecurityImmutable security) { _bus.post(ShowLadderTag, new ShowLadderMessage(security)); } public void show_order_modify(Order order) { _bus.post(ShowOrderModifyTag, new ShowOrderModifyMessage(order)); } public void show_order_ticket(Order order) { _orders_model.show_order_ticket(order); } - public void set_securities(IEnumerable securities) { _securities_subject.OnNext(new HashSet(securities.Select(s => s.Id))); } + public void set_securities(IEnumerable securities) { _securities_subject.OnNext(new HashSet(securities.Select(s => s.Id))); } public void Dispose() { Disposable.dispose(_subs); _securities_subject.Dispose(); diff --git a/src/client/spark/mspark/MarketView/MarketViewRow.cs b/src/client/spark/mspark/MarketView/MarketViewRow.cs index a926e0795..12c085dd6 100644 --- a/src/client/spark/mspark/MarketView/MarketViewRow.cs +++ b/src/client/spark/mspark/MarketView/MarketViewRow.cs @@ -80,7 +80,7 @@ namespace mbts.spark private void _animation_AnimationsChanged() { RaisePropertyChanged(nameof(animations)); } #region Bound Properties - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public RXReadOnlyDataGridCell position { get; } public RXReadOnlyDataGridCell last_price { get; } public RXReadOnlyDataGridCell last_size { get; } diff --git a/src/client/spark/mspark/MarketView/MarketViewVM.cs b/src/client/spark/mspark/MarketView/MarketViewVM.cs index ea2095896..96560bcfd 100644 --- a/src/client/spark/mspark/MarketView/MarketViewVM.cs +++ b/src/client/spark/mspark/MarketView/MarketViewVM.cs @@ -26,7 +26,7 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "MarketView"; - public MarketViewVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + public MarketViewVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { _bus = bus; _resources.Add(_model = new MarketViewModel(bus)); _resources.Add(_rows = new RXObservableCollection(_model.rows)); @@ -80,8 +80,8 @@ namespace mbts.spark } } - private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).DistinctUntilChanged(); } - private static Security _get_security(DataGridCellInfo cell) { return (cell.Item as Row)?.security.value; } + private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).Where(s => s.HasValue).Select(s => s.Value).DistinctUntilChanged(); } + private static SecurityImmutable? _get_security(DataGridCellInfo cell) { return (cell.Item as Row)?.security.value; } private static Order _create_order(DataGridCellInfo cell) { return _create_order((Row)cell.Item, (Columns)DataGridEx.GetArgument(cell.Column)); } private static Order _create_order(Row row, Columns col) { var order = OrderDataHelper.Defaults.Order(row.security.value, Order.AlgoOrderTypeOneofCase.MarketOrder); @@ -114,8 +114,8 @@ namespace mbts.spark public class StartupData { public const int Version = 1; public StartupData() { } - public StartupData(Security[] securities, SortingCriteria[] sorting_criteria) { - if (securities != null) this.securities = securities.Select(s => s.ToByteArray()).ToArray(); + public StartupData(SecurityImmutable[] securities, SortingCriteria[] sorting_criteria) { + if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } [ProtoMember(1)] diff --git a/src/client/spark/mspark/Orders/IOrderBook.cs b/src/client/spark/mspark/Orders/IOrderBook.cs index e4fa4fabf..ae479d993 100644 --- a/src/client/spark/mspark/Orders/IOrderBook.cs +++ b/src/client/spark/mspark/Orders/IOrderBook.cs @@ -11,34 +11,34 @@ namespace mbts.spark IEnumerable get_all_orders(); } - public static class OrderBookExtensions + static class OrderBookExtensions { - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, Security security) { return ob.get_all_orders_for_security(security.Id); } - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_orders_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_all_orders_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_orders_for_security(security.Id); } + public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_orders_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_all_orders_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders().Where(e => e.sec_key() == security); } public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_orders_for_security(new HashSet(securities)); } public static IEnumerable get_all_orders_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders().Where(e => securities.Contains(e.sec_key())); } public static IDictionary> get_order_sec_map(this IOrderBook ob) { return ob.get_all_orders().Map(e => e.sec_key()); } public static IEnumerable get_active_orders(this IOrderBook ob) { return ob.get_all_orders().Where(e => e.is_active()); } - public static IEnumerable get_active_orders_for_security(this IOrderBook ob, Security security) { return ob.get_active_orders_for_security(security.Id); } - public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_active_orders_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_active_orders_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_active_orders_for_security(security.Id); } + public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_active_orders_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders().Where(e => e.sec_key() == security && e.is_active()); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_active_orders_for_security(new HashSet(securities)); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders().Where(e => securities.Contains(e.sec_key()) && e.is_active()); } public static IDictionary> get_active_order_sec_map(this IOrderBook ob) { return ob.get_active_orders().Map(e => e.sec_key()); } public static IEnumerable get_all_fills(this IOrderBook ob) { return ob.get_all_orders().SelectMany(e => e.Fills); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, Security security) { return ob.get_all_fills_for_security(security.Id); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fills_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_all_fills_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_fills_for_security(security.Id); } + public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fills_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_all_fills_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders_for_security(security).SelectMany(e => e.Fills); } public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_fills_for_security(new HashSet(securities)); } public static IEnumerable get_all_fills_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders_for_security(securities).SelectMany(e => e.Fills); } public static IDictionary> get_fill_sec_map(this IOrderBook ob) { return ob.get_all_fills().Map(f => f.Order.Security.Id); } public static IEnumerable get_all_fill_tuples(this IOrderBook ob) { return ob.get_all_orders().SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, Security security) { return ob.get_all_fill_tuples_for_security(security.Id); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fill_tuples_for_security(new HashSet(security.Select(s => s.Id))); } + public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_fill_tuples_for_security(security.Id); } + public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fill_tuples_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders_for_security(security).SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_fill_tuples_for_security(new HashSet(securities)); } public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders_for_security(securities).SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } diff --git a/src/client/spark/mspark/Orders/OrderExtensions.cs b/src/client/spark/mspark/Orders/OrderExtensions.cs index 7e1c5fa05..3d57f06c1 100644 --- a/src/client/spark/mspark/Orders/OrderExtensions.cs +++ b/src/client/spark/mspark/Orders/OrderExtensions.cs @@ -53,7 +53,7 @@ namespace mbts.spark var parts = new List(); if (show_side) parts.Add(order.Side); if (show_security) parts.Add(order.Security.ToString(null)); - if (show_price) parts.Add(order.Security.ContractSpec.format(order.Price)); + if (show_price) parts.Add(((SecurityImmutable)order.Security).ContractSpec.format(order.Price)); if (show_qty) parts.Add("@ {0}".fmt(order.Size)); return string.Join(" ", parts); } diff --git a/src/client/spark/mspark/Orders/OrderTicketVM.cs b/src/client/spark/mspark/Orders/OrderTicketVM.cs index 2f5ad58b2..13fb3d61f 100644 --- a/src/client/spark/mspark/Orders/OrderTicketVM.cs +++ b/src/client/spark/mspark/Orders/OrderTicketVM.cs @@ -19,7 +19,7 @@ namespace mbts.spark return _order; }).Publish(); order_params = new OrderParamsVM(order_pub, model); - bbo = new BBOVM(order.Select(o => o.Security)); + bbo = new BBOVM(order.Select(o => (SecurityImmutable)o.Security)); size_calculator = new CalculatorLogic(0, settings.Select(s => s.calculator_buttons)); set_price_command = new DelegateCommand(p => { price = p; RaisePropertyChanged(nameof(price)); }); send_order = new DelegateCommand(side => { _prepare_order(side); model.send_order(_order); }); diff --git a/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs b/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs index 073b6b11e..9b467ed3f 100644 --- a/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs +++ b/src/client/spark/mspark/Orders/Sim/OrderActivitySimulator.cs @@ -12,14 +12,14 @@ namespace mbts.spark { private readonly OrderHub _hub = null; private readonly IBus _bus = null; - private IDictionary _md_map = new Dictionary(); + private IReadOnlyDictionary _md_map = new Dictionary(); private OrderBook _orderbook = new OrderBook(); public OrderActivitySimulator(OrderHub order_hub, IBus bus) { _hub = order_hub; _bus = bus; - _bus.subscribe>(SparkTags.SecuritiesTag).ObserveOnDispatcher().Subscribe(m => _md_map = m); + _bus.subscribe(SparkTags.SecuritiesTag).ObserveOnDispatcher().Subscribe(m => _md_map = m); _hub.on_new_order += _hub_on_new_order; _hub.on_cancel += _hub_on_order_cancel; _hub.on_price_change += _hub_on_order_price_change; diff --git a/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs b/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs index 4a7a378df..62ea02b20 100644 --- a/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs +++ b/src/client/spark/mspark/Orders/Sim/SimExchangeGateway.cs @@ -12,7 +12,7 @@ namespace mbts.spark { private readonly IBus _bus; private readonly Venue _venue; - private IDictionary _md_map = new ConcurrentDictionary(); + private IReadOnlyDictionary _md_map = new ConcurrentDictionary(); private IDictionary _worker_map = new ConcurrentDictionary(); public SimExchangeGateway(IBus bus, Venue venue) @@ -88,9 +88,9 @@ namespace mbts.spark internal IObservable on_fills { get { return _fill_sub; } } - internal IObservable> on_md + internal IObservable> on_md { - get { return _bus.subscribe>(SparkTags.SecuritiesTag); } + get { return _bus.subscribe(SparkTags.SecuritiesTag); } } #endregion diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs index e2ac6ee45..bafe55598 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs @@ -8,8 +8,8 @@ namespace mbts.spark { internal class SecuritySelectorDialogVM : SecuritySelectorVM { - public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit) : this (title, preselected_securities, commit, SecuritySource.GetObservable()) { } - public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit, IObservable securities_stream) : base(preselected_securities, securities_stream) { + public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit) : this (title, preselected_securities, commit, SecuritySource.GetObservable()) { } + public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit, IObservable securities_stream) : base(preselected_securities, securities_stream) { this.title = title; this.commit = new DelegateCommand(() => commit(selected_securities)); } diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs index 9462c7058..9e7f04566 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs @@ -7,17 +7,17 @@ using System.Threading; namespace mbts.spark { - public class SecuritySelectorVM : IDisposable + class SecuritySelectorVM : IDisposable { - public SecuritySelectorVM() : this(new Security[0]) { } - public SecuritySelectorVM(IReadOnlyCollection preselected_securities) : this(preselected_securities, SecuritySource.GetObservable()) { } - public SecuritySelectorVM(IReadOnlyCollection preselected_securities, IObservable securities_stream) { - selected_securities = new ObservableCollection(preselected_securities); - securities = new RXObservableCollection(securities_stream, SynchronizationContext.Current, TimeSpan.FromSeconds(1), SecurityHelper.IDEqualityComparer); + public SecuritySelectorVM() : this(new SecurityImmutable[0]) { } + public SecuritySelectorVM(IReadOnlyCollection preselected_securities) : this(preselected_securities, SecuritySource.GetObservable()) { } + public SecuritySelectorVM(IReadOnlyCollection preselected_securities, IObservable securities_stream) { + selected_securities = new ObservableCollection(preselected_securities); + securities = new RXObservableCollection(securities_stream, SynchronizationContext.Current, TimeSpan.FromSeconds(1)); } - public RXObservableCollection securities { get; } - public ObservableCollection selected_securities { get; } + public RXObservableCollection securities { get; } + public ObservableCollection selected_securities { get; } protected virtual void OnDispose() { } public void Dispose() { securities.Dispose(); } diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs index e065364ca..ea162f69e 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs @@ -11,10 +11,11 @@ namespace mbts.spark { internal static class SecuritySource { - public static IObservable GetObservable() { + public static IObservable GetObservable() { return _instance.publisher.AsObservable(); } + // EVIL private static InternalSource _instance; [Export(typeof(IInitializable))] @@ -22,12 +23,12 @@ namespace mbts.spark { [ImportingConstructor] public InternalSource(IBus bus) { - publisher = new StatePublisher(bus.subscribe>(SparkTags.SecuritiesTag) + publisher = new StatePublisher(bus.subscribe(SparkTags.SecuritiesTag) .Select(m => m.Values.Select(s => s.security).Ordered(SecurityDataHelper.Comparer.Instance).ToArray())); _instance = this; } - internal readonly StatePublisher publisher; + internal readonly StatePublisher publisher; public int priority => int.MaxValue; public void initialize() { } diff --git a/src/client/spark/mspark/Shell/Fills/FillsVM.cs b/src/client/spark/mspark/Shell/Fills/FillsVM.cs index 4187d343f..dd39990c8 100644 --- a/src/client/spark/mspark/Shell/Fills/FillsVM.cs +++ b/src/client/spark/mspark/Shell/Fills/FillsVM.cs @@ -24,10 +24,10 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "Fills"; - public FillsVM(IBus bus, OrdersModel model, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { + public FillsVM(IBus bus, OrdersModel model, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { _bus = bus; _model = model; - _securities = new HashSet(securities ?? Enumerable.Empty()); + _securities = new HashSet(securities ?? Enumerable.Empty()); _rows = new ObservableAutoWrapper(_fills, f => new Row(f, _model)); rows_view = CollectionViewSource.GetDefaultView(_rows); if (sorting_criteria != null) rows_view.SortDescriptions.AddRange(sorting_criteria.Select(sc => sc.to_sort_description())); @@ -39,7 +39,7 @@ namespace mbts.spark modify_security_selection = new DialogCommand(() => new SecuritySelectorDialog { DataContext = new SecuritySelectorDialogVM("Fills", _securities.ToArray(), secs => { - _securities = new HashSet(secs); + _securities = new HashSet(secs); _update(); }) }, () => true, true, -12, -30); @@ -49,7 +49,7 @@ namespace mbts.spark private readonly OrdersModel _model; private readonly ObservableCollection _fills = new ObservableCollection(); private readonly ObservableAutoWrapper _rows; - private HashSet _securities; + private HashSet _securities; private IOrderBook _order_book = new OrderBook(); private List _update_log = new List(); private ContextMenuVM _context_menu; @@ -64,7 +64,7 @@ namespace mbts.spark } private IEnumerable _context_menu_item_factory() { var selected_rows = _rows.Where(r => r.is_selected); - var securities = new HashSet(selected_rows.Select(r => r.security.value)); + var securities = new HashSet(selected_rows.Select(r => r.security.value)); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); yield return MenuItemVM.Create(new OrderTicketMenuItem(_model), securities); yield return MenuItemVM.Create(new MarketViewMenuItem(_bus), securities); @@ -92,7 +92,7 @@ namespace mbts.spark _fill = fill.Fill; _entry = fill.OrderBookEntry; _model = model; - security = new SelectableViewModelBase(_fill.Order.Security, SecurityDataHelper.Comparer.Instance); + security = new SelectableViewModelBase(_fill.Order.Security, SecurityDataHelper.Comparer.Instance); uint aggr_fills = 0; foreach (var f in _entry.Fills) if (f.Timestamp <= _fill.Timestamp) aggr_fills += f.Size; order_percentage = (double)aggr_fills / (double)_fill.Order.Size; @@ -109,7 +109,7 @@ namespace mbts.spark public string account => _fill.Order.Account; public string user => _fill.Order.User; public Venue exchange => _fill.Order.Security.Exchange; - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public Side side => _fill.Order.Side; public double price => _fill.Price; public uint size => _fill.Size; @@ -127,8 +127,8 @@ namespace mbts.spark public class StartupData { public const int Version = 1; public StartupData() { } - public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { - if (securities != null) this.securities = securities.Select(s => s.ToByteArray()).ToArray(); + public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { + if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } [ProtoMember(1)] diff --git a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs index 7a01bdd09..69b7fb964 100644 --- a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs +++ b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs @@ -68,9 +68,9 @@ namespace mbts.spark.menu_items { internal SecurityLaunchMenuItem(string display_name, string sectional_id, ImageSource icon, ICommand launch_command, Template template_key, IDisposable dispose) : base(display_name, sectional_id, icon, template_key:template_key, dispose:dispose) { this.launch_command = launch_command; } - private RXObservableCollection _securities = new RXObservableCollection(SecuritySource.GetObservable()); - public RXObservableCollection securities => _securities; - public ObservableCollection selected_securities { get; } = new ObservableCollection(); + private RXObservableCollection _securities = new RXObservableCollection(SecuritySource.GetObservable()); + public RXObservableCollection securities => _securities; + public ObservableCollection selected_securities { get; } = new ObservableCollection(); public ICommand launch_command { get; } protected override void Dispose(bool disposing) { Disposable.dispose(ref _securities); } } diff --git a/src/client/spark/mspark/Shell/MarketModule.cs b/src/client/spark/mspark/Shell/MarketModule.cs index 9f315d05e..3b88bd3f4 100644 --- a/src/client/spark/mspark/Shell/MarketModule.cs +++ b/src/client/spark/mspark/Shell/MarketModule.cs @@ -27,7 +27,7 @@ namespace mbts.spark _bus = bus; _wm = wm; _dispose = Disposable.Create( - _bus.subscribe>(SecuritiesTag).ObserveOnDispatcher().Subscribe(s => _securities = s), + _bus.subscribe(SecuritiesTag).ObserveOnDispatcher().Subscribe(s => _securities = s), _bus.subscribe(SyntheticSecuritiesTag).ObserveOnDispatcher().Subscribe(ssm => _synthetic_strategy_map = ssm.data), _bus.subscribe(ShowMarketViewTag).ObserveOnDispatcher().Subscribe(show_market_view), _bus.subscribe(ShowSpreadMatrixTag).ObserveOnDispatcher().Subscribe(show_spread_matrix), @@ -43,7 +43,7 @@ namespace mbts.spark private readonly IBus _bus; private readonly IWindowManager _wm; private readonly IDisposable _dispose; - private IDictionary _securities = new Dictionary(); + private IReadOnlyDictionary _securities = new Dictionary(); private IDictionary _synthetic_strategy_map = new Dictionary(); public int priority => 2; @@ -68,7 +68,7 @@ namespace mbts.spark if (_securities != null && _securities.TryGetValue((uint)header.version, out SecurityMD md)) return create_ladder_window(md); else break; case MarketViewVM.SAVE_NAME: - if (try_deserialize(load_stream, out MarketViewVM.StartupData data)) return create_market_view(data.securities.Select(deserialize).ToList(), data.sorting_criteria); + if (try_deserialize(load_stream, out MarketViewVM.StartupData data)) return create_market_view(data.securities.Select(x => (SecurityImmutable)deserialize(x)).ToList(), data.sorting_criteria); else break; } } @@ -83,7 +83,7 @@ namespace mbts.spark #region MarketView private void show_market_view(ShowMarketViewMessage msg) { _wm.Windows.Add(create_market_view(msg.data, null)); } - private IShellWindow create_market_view(IReadOnlyCollection securities, IReadOnlyCollection sorting) { + private IShellWindow create_market_view(IReadOnlyCollection securities, IReadOnlyCollection sorting) { var vm = new MarketViewVM(_bus, securities, sorting); var view = new MarketViewView { DataContext = vm }; const double two_thirds = 2.0 / 3.0; @@ -170,7 +170,7 @@ namespace mbts.spark string warn_msg = $"Did not find execution strategy for {msg.data}"; Logger.warn(bts.log.Subsystem.Ui, warn_msg); show_synthetic_editor_warning(warn_msg); - } else show_synthetic_editor(msg.data, ses.ExecutionStrategy); + } else show_synthetic_editor(msg.data.CloneToMutable(), ses.ExecutionStrategy); } private void show_synthetic_editor_warning(string warn_msg) { BTSMessageBox.Show(warn_msg, "Synthetic Strategy", MessageBoxButton.OK, MessageBoxImage.Exclamation, true, false, true); diff --git a/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs index 3feab29ab..59bc0bae9 100644 --- a/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs @@ -22,11 +22,11 @@ namespace mbts.spark.menu_items public int priority => 0; public ImageSource icon => Icons.CancelOrders; public string sectional_id => MenuItemSections.OrderOp; - public void execute(IReadOnlyCollection securities) { + public void execute(IReadOnlyCollection securities) { var orders = _orderbook.get_all_orders().Select(e => e.order()).Where(o => securities.Contains(o.Security) && filter(o)).Select(o => o.Id).ToList(); _model.cancel_order(orders); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs index 79c785a8e..d8f10f860 100644 --- a/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/IMenuItem.cs @@ -25,10 +25,10 @@ namespace mbts.spark.menu_items bool can_execute(); } - public interface IMenuSecuritiesActionItem : IMenuItem, ICanExecuteChanged + interface IMenuSecuritiesActionItem : IMenuItem, ICanExecuteChanged { - void execute(IReadOnlyCollection securities); - bool can_execute(IReadOnlyCollection securities); + void execute(IReadOnlyCollection securities); + bool can_execute(IReadOnlyCollection securities); } public interface IMenuGroupItem : IMenuItem diff --git a/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs index 4ad04ec54..00d035135 100644 --- a/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/LadderMenuItem.cs @@ -20,8 +20,8 @@ namespace mbts.spark.menu_items public int priority => 2; public ImageSource icon => Icons.Depth; public string sectional_id => MenuItemSections.OrderActiveWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(ShowLadderTag, new ShowLadderMessage(securities)); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } + public void execute(IReadOnlyCollection securities) { _bus.post(ShowLadderTag, new ShowLadderMessage(securities)); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs index 616f1a78f..fd5e6a20c 100644 --- a/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/MarketViewMenuItem.cs @@ -19,8 +19,8 @@ namespace mbts.spark.menu_items public int priority => 0; public ImageSource icon => Icons.Sheets; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowMarketViewTag, new SparkBusData.ShowMarketViewMessage(securities.ToList())); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } + public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowMarketViewTag, new SparkBusData.ShowMarketViewMessage(securities.ToList())); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs b/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs index 0c61523e6..d8846029c 100644 --- a/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs +++ b/src/client/spark/mspark/Shell/MenuItems/MenuItemVM.cs @@ -15,18 +15,18 @@ using System.Windows.Media; namespace mbts.spark.menu_items { - public class MenuItemVM : DisposableViewModelBase + class MenuItemVM : DisposableViewModelBase { #region Static Factory - public static IList CreateMenu(ObservableCollection selected_securities, params IMenuItem[] menu_items) { + public static IList CreateMenu(ObservableCollection selected_securities, params IMenuItem[] menu_items) { return menu_items.Select(m => Create(m, selected_securities)).ToList(); } - public static IList CreateMenu(IReadOnlyCollection selected_securities, params IMenuItem[] menu_items) { + public static IList CreateMenu(IReadOnlyCollection selected_securities, params IMenuItem[] menu_items) { return menu_items.Select(m => Create(m, selected_securities)).ToList(); } - public static MenuItemVM Create(IMenuItem model, ObservableCollection selected_securities) { + public static MenuItemVM Create(IMenuItem model, ObservableCollection selected_securities) { var act_mi = model as IMenuActionItem; if (act_mi != null) return Create(act_mi); var secs_mi = model as IMenuSecuritiesActionItem; @@ -36,7 +36,7 @@ namespace mbts.spark.menu_items throw new NotImplementedException("LaunchMenuVM cannot create vm for {0} ({1}).".fmt(model?.display_name ?? "unnamed", model?.GetType().ToString() ?? "null")); } - public static MenuItemVM Create(IMenuItem model, IReadOnlyCollection selected_securities) { + public static MenuItemVM Create(IMenuItem model, IReadOnlyCollection selected_securities) { var act_mi = model as IMenuActionItem; if (act_mi != null) return Create(act_mi); var secs_mi = model as IMenuSecuritiesActionItem; @@ -50,21 +50,21 @@ namespace mbts.spark.menu_items return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, _hook_command(model, model.execute, model.can_execute), dispose: model as IDisposable); } - public static MenuItemVM Create(IMenuSecuritiesActionItem model, IReadOnlyCollection selected_securities) { + public static MenuItemVM Create(IMenuSecuritiesActionItem model, IReadOnlyCollection selected_securities) { return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, _hook_command(model, () => model.execute(selected_securities), () => model.can_execute(selected_securities))); } - public static MenuItemVM Create(IMenuSecuritiesActionItem model, ObservableCollection selected_securities) { + public static MenuItemVM Create(IMenuSecuritiesActionItem model, ObservableCollection selected_securities) { var command = _hook_command(model, () => model.execute(selected_securities), () => model.can_execute(selected_securities)); IDisposable sub = selected_securities.Subscribe((s, e) => command.RaiseCanExecuteChanged()); return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, command, dispose: Disposable.Create(() => { (model as IDisposable)?.Dispose(); sub?.Dispose(); })); } - public static MenuItemVM Create(IMenuGroupItem model, ObservableCollection selected_securities) { + public static MenuItemVM Create(IMenuGroupItem model, ObservableCollection selected_securities) { return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, new DelegateCommand(() => { }, () => model.items.Any()), CreateMenu(selected_securities, model.items.ToArray())); } - public static MenuItemVM Create(IMenuGroupItem model, IReadOnlyCollection selected_securities) { + public static MenuItemVM Create(IMenuGroupItem model, IReadOnlyCollection selected_securities) { return new MenuItemVM(_observe_display_name(model), model.sectional_id, model.icon, new DelegateCommand(() => { }, () => model.items.Any()), CreateMenu(selected_securities, model.items.ToArray())); } diff --git a/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs index 43e97e1c4..00c424c39 100644 --- a/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs @@ -9,14 +9,14 @@ namespace mbts.spark.menu_items { internal class ModifySecuritySelectionMenuItem : IMenuActionItem { - public ModifySecuritySelectionMenuItem(IReadOnlyCollection securities, Action> commit, string dialog_title="Select Securities") { + public ModifySecuritySelectionMenuItem(IReadOnlyCollection securities, Action> commit, string dialog_title="Select Securities") { _securities = securities; _commit = commit; _dialog_title = dialog_title; } private readonly string _dialog_title; - private readonly IReadOnlyCollection _securities; - private readonly Action> _commit; + private readonly IReadOnlyCollection _securities; + private readonly Action> _commit; public string display_name => "Add/Remove Securities"; public int priority => int.MinValue; public ImageSource icon => Icons.Coins; diff --git a/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs index a4bc181bd..88e6e2a49 100644 --- a/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs @@ -13,20 +13,20 @@ namespace mbts.spark.menu_items { internal class OrderTicketMenuItem : IMenuSecuritiesActionItem { - public OrderTicketMenuItem(OrdersModel model, Func order_factory=null) { + public OrderTicketMenuItem(OrdersModel model, Func order_factory=null) { _model = model; - _order_factory = order_factory ?? new Func(s => new Order { Security = s, LimitOrder = new LimitOrder(), Size = 1 }); + _order_factory = order_factory ?? new Func(s => new Order { Security = s.CloneToMutable(), LimitOrder = new LimitOrder(), Size = 1 }); } private readonly OrdersModel _model; - private readonly Func _order_factory; + private readonly Func _order_factory; public string display_name => "Order Ticket"; public int priority => 3; public ImageSource icon => Icons.Ticket; public string sectional_id => MenuItemSections.OrderActiveWindow; - public void execute(IReadOnlyCollection securities) { _model.show_order_ticket(securities.Select(_order_factory).ToList()); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } + public void execute(IReadOnlyCollection securities) { _model.show_order_ticket(securities.Select(_order_factory).ToList()); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 0; } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; @@ -35,7 +35,7 @@ namespace mbts.spark.menu_items internal class LinkedOrderTicketMenuItem : IMenuActionItem { - public LinkedOrderTicketMenuItem(IBus bus, IObservable security, Func order_factory) : this(bus, security.Select(order_factory).Where(o => o != null)) { } + public LinkedOrderTicketMenuItem(IBus bus, IObservable security, Func order_factory) : this(bus, security.Select(order_factory).Where(o => o != null)) { } public LinkedOrderTicketMenuItem(IBus bus, IObservable order) { _bus = bus; _order = order; diff --git a/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs index d16a43673..0af9e2d2a 100644 --- a/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/SpreadMatrixMenuItem.cs @@ -19,8 +19,8 @@ namespace mbts.spark.menu_items public int priority => 1; public ImageSource icon => Icons.Cube3d; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowSpreadMatrixTag, new SparkBusData.ShowSpreadMatrixMessage(securities.ToList())); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } + public void execute(IReadOnlyCollection securities) { _bus.post(SparkTags.ShowSpreadMatrixTag, new SparkBusData.ShowSpreadMatrixMessage(securities.ToList())); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs index 9e52eabec..398e34d9d 100644 --- a/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/SyntheticCreateMenuItem.cs @@ -22,8 +22,8 @@ namespace mbts.spark.menu_items public int priority => 2; public ImageSource icon => Icons.Tetris; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticCreateTag, new ShowSyntheticCreateMessage(securities)); } - public bool can_execute(IReadOnlyCollection securities) { + public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticCreateTag, new ShowSyntheticCreateMessage(securities)); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count > 1 || (securities.Count == 1 && (securities.First().ContractCase == ContractOneofCase.Synthetic || securities.First().ContractCase == ContractOneofCase.Spread)); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } diff --git a/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs index 5380e078a..26acf54ed 100644 --- a/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/SyntheticStrategyMenuItem.cs @@ -21,8 +21,8 @@ namespace mbts.spark.menu_items public int priority => 1; public ImageSource icon => Icons.Knight; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticStrategyTag, new ShowSyntheticStrategyMessage(securities.First())); } - public bool can_execute(IReadOnlyCollection securities) { return securities.Count == 1 && securities.First().ContractCase == Security.ContractOneofCase.Synthetic; } + public void execute(IReadOnlyCollection securities) { _bus.post(ShowSyntheticStrategyTag, new ShowSyntheticStrategyMessage(securities.First())); } + public bool can_execute(IReadOnlyCollection securities) { return securities.Count == 1 && securities.First().ContractCase == Security.ContractOneofCase.Synthetic; } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs index c19acea3f..25bbd6ff3 100644 --- a/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/TimeAndSalesMenuItem.cs @@ -7,7 +7,7 @@ using System.Windows.Media; namespace mbts.spark.menu_items { - public class TimeAndSalesMenuItem : IMenuSecuritiesActionItem + class TimeAndSalesMenuItem : IMenuSecuritiesActionItem { public TimeAndSalesMenuItem(IBus bus) { _bus = bus; @@ -19,8 +19,8 @@ namespace mbts.spark.menu_items public int priority => 4; public ImageSource icon => Icons.Clock; public string sectional_id => MenuItemSections.SecurityWindow; - public void execute(IReadOnlyCollection ordered_selection) { _bus.post(SparkTags.ShowTimeAndSalesTag, new SparkBusData.ShowTimeAndSalesMessage(ordered_selection.ToList())); } - public bool can_execute(IReadOnlyCollection ordered_selection) { return ordered_selection.Any(); } + public void execute(IReadOnlyCollection ordered_selection) { _bus.post(SparkTags.ShowTimeAndSalesTag, new SparkBusData.ShowTimeAndSalesMessage(ordered_selection.ToList())); } + public bool can_execute(IReadOnlyCollection ordered_selection) { return ordered_selection.Any(); } public void raise_display_name_changed() { display_name_changed?.Invoke(); } public void raise_can_execute_changed() { can_execute_changed?.Invoke(); } public event Action display_name_changed; diff --git a/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs b/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs index 823378dcb..8af4a9111 100644 --- a/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs +++ b/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs @@ -17,7 +17,7 @@ namespace mbts.spark _parent = parent; _model = model; _order = entry; - security = new SelectableViewModelBase(_order.order().Security, SecurityDataHelper.Comparer.Instance); + security = new SelectableViewModelBase(_order.order().Security, SecurityDataHelper.Comparer.Instance); _visible = backing(nameof(is_visible), !is_child); _expanded = backing(nameof(is_expanded), false); details_command = new DelegateCommand(() => _model.show_order_details(order_id)); @@ -37,7 +37,7 @@ namespace mbts.spark // the grid view uses this for sorting, it was just a bts.api.Security once upon a time, but that class no longer implements IComparable // this SelectableViewModeBase is essentially a wrapper class, which implements ISelecatble and IComparable - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public OrderBookEntry order => _order; public string security_text { // indent child 3 spaces @@ -114,7 +114,7 @@ namespace mbts.spark public double average_price { get => _order.Fills.Count > 0 ? - _order.order().Security.ContractSpec.round_to_tick( + ((SecurityImmutable)_order.order().Security).ContractSpec.round_to_tick( _order.Fills.Sum(f => f.Price * f.Size) / _order.Fills.Sum(f => f.Size)) : 0; set => ignore(); diff --git a/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs b/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs index ccaf82668..da9afb041 100644 --- a/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs +++ b/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs @@ -80,7 +80,7 @@ namespace mbts.spark { private IEnumerable _context_menu_item_factory() { var selected_rows = this.orders.Where(vm => vm.is_selected && vm.is_visible).ToList(); var orders = selected_rows.Select(vm => vm.order).ToList(); - var securities = new HashSet(selected_rows.Select(vm => vm.security.value)); + var securities = new HashSet(selected_rows.Select(vm => vm.security.value)); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); yield return MenuItemVM.Create(new OrderTicketMenuItem(_model), securities); yield return MenuItemVM.Create(new MarketViewMenuItem(_bus), securities); diff --git a/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs b/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs index 13147fe37..fc8d977f6 100644 --- a/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs +++ b/src/client/spark/mspark/Shell/Securities/Synthetic/SyntheticEditorModel.cs @@ -4,7 +4,6 @@ using Google.Protobuf; using System; using System.Collections.Generic; using System.Reactive.Linq; -using MDMap = System.Collections.Generic.Dictionary; namespace mbts.spark { @@ -24,7 +23,7 @@ namespace mbts.spark /// The new strategy to create, or existing strategy modify public async void save(Security synthetic, ExecutionStrategy strategy) { if (synthetic.ContractCase != Security.ContractOneofCase.Synthetic) throw new ArgumentException("Must be a synthetic security.", nameof(synthetic)); - var map = await _bus.subscribe(SparkTags.SecuritiesTag).FirstAsync(); + var map = await _bus.subscribe(SparkTags.SecuritiesTag).FirstAsync(); if (synthetic.Id == 0) { // CREATE var curr_secmap = new HashSet(map.Keys); @@ -32,7 +31,7 @@ namespace mbts.spark while (curr_secmap.Contains(id)) id--; synthetic.Id = id; var sec_strategy = new SyntheticExecutionStrategy { Security = synthetic, ExecutionStrategy = strategy }; - _bus.post(SparkTags.PersistCommandTag, new SparkBusData.PersistMessage(1, "SyntheticSecurity", String.Empty, sec_strategy.ToByteArray())); + _bus.post(SparkTags.PersistCommandTag, new SparkBusData.PersistMessage(1, "SyntheticSecurity", String.Empty, ((IImmutableMessage)sec_strategy).ToByteArray())); } else { // MODIFY } diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs index 2636793c1..b7af9bf12 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs @@ -12,7 +12,7 @@ namespace mbts.spark { internal class TimeAndSalesModel : IDisposable { - public TimeAndSalesModel(IBus bus, IReadOnlyCollection securities) { + public TimeAndSalesModel(IBus bus, IReadOnlyCollection securities) { set_securities(securities); _orders_model = new OrdersModel(bus); _work_loop = WorkLoop.Start(_refresh); @@ -21,25 +21,25 @@ namespace mbts.spark private readonly IDisposable _work_loop; private readonly OrdersModel _orders_model; - private readonly Subject>> _trades = new Subject>>(); - private readonly Dictionary _channels = new Dictionary(); + private readonly Subject>> _trades = new Subject>>(); + private readonly Dictionary _channels = new Dictionary(); private void _refresh() { var ts = _channels.SelectMany(kv => kv.Value.read_trades().Select(t => Tuple.Create(kv.Key, t))).ToList(); if (ts.Count > 0) _trades.OnNext(ts); } - private static IEnumerable _get_real_securities(Security security) { + private static IEnumerable _get_real_securities(SecurityImmutable security) { if (security.ContractCase == Security.ContractOneofCase.Synthetic) foreach (var s in security.Synthetic.Legs.Select(l => l.Security).SelectMany(_get_real_securities)) yield return s; else yield return security; } - public IObservable>> trades => _trades.AsObservable(); - public IReadOnlyCollection securities => _channels.Keys; + public IObservable>> trades => _trades.AsObservable(); + public IReadOnlyCollection securities => _channels.Keys; public OrdersModel orders_model => _orders_model; - public void set_securities(IEnumerable securities) { + public void set_securities(IEnumerable securities) { var real_secs = securities.SelectMany(_get_real_securities); foreach (var r in _channels.Keys.Except(real_secs).ToList()) _channels.Remove(r); foreach (var a in real_secs.Except(_channels.Keys).ToList()) { diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs index d5564e1cf..f7967fea5 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs @@ -26,10 +26,10 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "TimeAndSales"; - public TimeAndSalesVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { + public TimeAndSalesVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { _bus = bus; _resources.Add(_model = new TimeAndSalesModel(bus, securities)); - _rows = new ObservableAutoWrapper>(_trades, tup => new Row(tup.Item1, tup.Item2)); + _rows = new ObservableAutoWrapper>(_trades, tup => new Row(tup.Item1, tup.Item2)); _rows.ViewDestroyed += r => r.Dispose(); _resources.Add(Disposable.Create(() => _rows.Clear())); rows_view = CollectionViewSource.GetDefaultView(_rows); @@ -53,15 +53,15 @@ namespace mbts.spark private readonly IBus _bus; private readonly TimeAndSalesModel _model; - private readonly ObservableCollection> _trades = new ObservableCollection>(); - private readonly ObservableAutoWrapper> _rows; + private readonly ObservableCollection> _trades = new ObservableCollection>(); + private readonly ObservableAutoWrapper> _rows; private readonly ContextMenuVM _context_menu; private readonly ColdObseravbleProperty _current_cell = new ColdObseravbleProperty(); private IList _resources = new List(); private IOrderBook _order_book = new OrderBook(); private IEnumerable _context_menu_item_factory() { - yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(new HashSet(_rows.Select(r => r.security.value)), _model.set_securities)); + yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(new HashSet(_rows.Select(r => r.security.value)), _model.set_securities)); if (current_cell != null && current_cell.Column != null && current_cell.Item != null && !current_cell.Item.Equals(System.Windows.DependencyProperty.UnsetValue)) { var securities = _rows.Where(r => r.is_selected).Select(r => r.security.value).ToList(); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); @@ -80,8 +80,8 @@ namespace mbts.spark } } - private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).DistinctUntilChanged(); } - private static Security _get_security(DataGridCellInfo cell) { return ((Row)cell.Item).security.value; } + private IObservable _get_current_security_observable() { return _current_cell.Select(_get_security).DistinctUntilChanged(); } + private static SecurityImmutable _get_security(DataGridCellInfo cell) { return ((Row)cell.Item).security.value; } public ICollectionView rows_view { get; private set; } public DataGridCellInfo current_cell { get => _current_cell.Value; set => _current_cell.set(value); } @@ -91,7 +91,7 @@ namespace mbts.spark public void Dispose() { Disposable.dispose(_resources); } private class Row : GridRowViewModelBase { - public Row(Security security, TradeMessage trade) { + public Row(SecurityImmutable security, TradeMessage trade) { this.security = AddCell(Columns.Security, security, SecurityDataHelper.Comparer.Instance); quantity = AddCell(Columns.Size, trade.Size); price = AddCell(Columns.Price, trade.Mantissa * Math.Pow(10, trade.Exponent)); @@ -99,7 +99,7 @@ namespace mbts.spark order_type = AddCell(Columns.OrderType, Order.AlgoOrderTypeOneofCase.None); } - public SelectableViewModelBase security { get; } + public SelectableViewModelBase security { get; } public SelectableViewModelBase quantity { get; } public SelectableViewModelBase price { get; } public SelectableViewModelBase trade_time { get; } @@ -110,8 +110,8 @@ namespace mbts.spark public class StartupData { public const int Version = 1; public StartupData() { } - public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { - if (securities != null) this.securities = securities.Select(s => s.ToByteArray()).ToArray(); + public StartupData(IReadOnlyCollection securities, SortingCriteria[] sorting_criteria) { + if (securities != null) this.securities = securities.Select(s => ((IImmutableMessage)s).ToByteArray()).ToArray(); this.sorting_criteria = sorting_criteria; } [ProtoMember(1)] diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs index 0cedfcb20..aba5d04e3 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs @@ -12,10 +12,10 @@ namespace mbts.spark { internal class TimeAndSalesWindow : IShellWindow { - public TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities) : this (owner, bus, securities, null) { } - public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data) : this(owner, bus, startup_data.securities.Select(deserialize).ToList(), startup_data.sorting_criteria) { } + public TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities) : this (owner, bus, securities, null) { } + public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data) : this(owner, bus, startup_data.securities.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria) { } - private TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + private TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { _bus = bus; _securities = securities; _sorting_criteria = sorting_criteria; @@ -23,7 +23,7 @@ namespace mbts.spark } private readonly IBus _bus; - private readonly IReadOnlyCollection _securities; + private readonly IReadOnlyCollection _securities; private readonly IReadOnlyCollection _sorting_criteria; private TimeAndSalesVM _vm; private IShellModule _owner; diff --git a/src/client/spark/mspark/Shell/TradesModule.cs b/src/client/spark/mspark/Shell/TradesModule.cs index ab7de6249..54b03548e 100644 --- a/src/client/spark/mspark/Shell/TradesModule.cs +++ b/src/client/spark/mspark/Shell/TradesModule.cs @@ -68,16 +68,16 @@ namespace mbts.spark return ShellWindow.create(this, "Order Book", view, vm.get_state); } - private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(deserialize).ToList(), startup_data.sorting_criteria); } - private IShellWindow create_fills_window(IReadOnlyCollection securities) { return create_fills_window(securities, null); } - private IShellWindow create_fills_window(IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria); } + private IShellWindow create_fills_window(IReadOnlyCollection securities) { return create_fills_window(securities, null); } + private IShellWindow create_fills_window(IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { var vm = new FillsVM(_bus, new OrdersModel(_bus), securities, sorting_criteria); var view = new FillsView { DataContext = vm, Width = 1024, Height = 800 }; return ShellWindow.create(this, "Fills", view, vm.get_state, Icons.Ticket); } private void show_order_book(ShowOrderBookMessage msg) { _wm.Windows.Add(create_order_book_window(new OrderBookState())); } - private void show_fills(ShowFillsMessage msg) { _wm.Windows.Add(create_fills_window(new List())); } + private void show_fills(ShowFillsMessage msg) { _wm.Windows.Add(create_fills_window(new List())); } private void show_audit_log(ShowAuditLogsMessage msg) { } private void show_positions(ShowPositionsMessage msg) { } private void show_time_and_sales(ShowTimeAndSalesMessage msg) { _wm.Windows.Add(new TimeAndSalesWindow(this, _bus, msg.data)); } diff --git a/src/client/spark/mspark/Utilities/BBOVM.cs b/src/client/spark/mspark/Utilities/BBOVM.cs index 4d85c8691..385483f36 100644 --- a/src/client/spark/mspark/Utilities/BBOVM.cs +++ b/src/client/spark/mspark/Utilities/BBOVM.cs @@ -10,8 +10,8 @@ namespace mbts.spark { public BBOVM(uint security) : this(Observable.Return(security)) { } public BBOVM(IObservable security) : this(security.ToSecurity()) { } - public BBOVM(IObservable security) : this(security, new SecurityMDPump(security)) { } - public BBOVM(IObservable security, ISecurityMDPump md_pump) { + public BBOVM(IObservable security) : this(security, new SecurityMDPump(security)) { } + public BBOVM(IObservable security, ISecurityMDPump md_pump) { _security = backing(nameof(security), security, Security.Empty); _bid = backing(nameof(bid), md_pump.bid_price, double.NaN); _ask = backing(nameof(ask), md_pump.ask_price, double.NaN); @@ -19,11 +19,11 @@ namespace mbts.spark _ask_size = backing(nameof(ask_size), md_pump.ask_size, (ushort)0); } - private readonly Property _security; + private readonly Property _security; private readonly Property _bid, _ask; private readonly Property _bid_size, _ask_size; - public Security security => _security.Value; + public SecurityImmutable security => _security.Value; public double bid => _bid.Value; public double ask => _ask.Value; public ushort bid_size => _bid_size.Value; diff --git a/src/client/spark/mspark/Utilities/ISecurityMDPump.cs b/src/client/spark/mspark/Utilities/ISecurityMDPump.cs index 1044c2893..e81bcb669 100644 --- a/src/client/spark/mspark/Utilities/ISecurityMDPump.cs +++ b/src/client/spark/mspark/Utilities/ISecurityMDPump.cs @@ -6,7 +6,6 @@ using System.Collections.Generic; using System.Linq; using System.Reactive.Linq; using System.Reactive.Subjects; -using MDMap = System.Collections.Generic.Dictionary; namespace mbts.spark.utilities { @@ -28,18 +27,18 @@ namespace mbts.spark.utilities internal class SecurityMDPump : ISecurityMDPump, IDisposable { - public SecurityMDPump(Security security) : this(security, WorkLoop.DefaultPollInterval) { } - public SecurityMDPump(Security security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } - public SecurityMDPump(Security security, IObservable poll) : this(security.Id, poll) { } - public SecurityMDPump(IObservable security) : this(security.Select(s => s.Id)) { } - public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security.Select(s => s.Id), poll_interval) { } - public SecurityMDPump(IObservable security, IObservable poll) : this(security.Select(s => s.Id), poll) { } + public SecurityMDPump(SecurityImmutable security) : this(security, WorkLoop.DefaultPollInterval) { } + public SecurityMDPump(SecurityImmutable security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } + public SecurityMDPump(SecurityImmutable security, IObservable poll) : this(security.Id, poll) { } + public SecurityMDPump(IObservable security) : this(security.Select(s => s.Id)) { } + public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security.Select(s => s.Id), poll_interval) { } + public SecurityMDPump(IObservable security, IObservable poll) : this(security.Select(s => s.Id), poll) { } public SecurityMDPump(uint security) : this(security, WorkLoop.DefaultPollInterval) { } public SecurityMDPump(uint security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } public SecurityMDPump(uint security, IObservable poll) : this(Observable.Return(security).ToSecurity(), poll) { } public SecurityMDPump(IObservable security) : this(security, WorkLoop.DefaultPollInterval) { } public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } - public SecurityMDPump(IObservable security, IObservable poll) : this(security.CombineLatest(ImportedResources.Bus.subscribe(SparkTags.SecuritiesTag), (s, m) => m.GetValueOrDefault(s).md).Where(md => md != null), poll) { } + public SecurityMDPump(IObservable security, IObservable poll) : this(security.CombineLatest(ImportedResources.Bus.subscribe(SparkTags.SecuritiesTag), (s, m) => m.GetValueOrDefault(s).md).Where(md => md != null), poll) { } public SecurityMDPump(IMDHandle md) : this(Observable.Return(md)) { } public SecurityMDPump(IMDHandle md, TimeSpan poll_interval) : this(Observable.Return(md), poll_interval) { } public SecurityMDPump(IMDHandle md, IObservable poll) : this(Observable.Return(md), poll) { } diff --git a/src/client/spark/mspark/Utilities/ImportedResources.cs b/src/client/spark/mspark/Utilities/ImportedResources.cs index c6df8bb03..9b5272e51 100644 --- a/src/client/spark/mspark/Utilities/ImportedResources.cs +++ b/src/client/spark/mspark/Utilities/ImportedResources.cs @@ -16,14 +16,14 @@ namespace mbts.spark.utilities public static readonly string[] Accounts = new[] { "Account1", "Account2", "Account3", "Account4" }; #region Misc Extensions (should put these in a more appropriate place eventually) - public static IObservable ToSecurity(this IObservable securityKey) { - return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk).security).Where(s => s != null); + public static IObservable ToSecurity(this IObservable securityKey) { + return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk).security); } public static IObservable ToSecurityMD(this IObservable securityKey) { - return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk)); + return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk)); } - public static IObservable ToSecurityMD(this IObservable security) { - return security.CombineLatest(Bus.subscribe(SecuritiesTag), (s, map) => map.GetValueOrDefault(s.Id)); + public static IObservable ToSecurityMD(this IObservable security) { + return security.CombineLatest(Bus.subscribe(SecuritiesTag), (s, map) => map.GetValueOrDefault(s.Id)); } #endregion diff --git a/src/client/spark/mspark/Utilities/OrderDataHelper.cs b/src/client/spark/mspark/Utilities/OrderDataHelper.cs index 493907091..29e5aa50b 100644 --- a/src/client/spark/mspark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/mspark/Utilities/OrderDataHelper.cs @@ -39,12 +39,12 @@ namespace mbts.spark.utilities BTSIcebergOrder }; - public static Order Order(Security security) { return Order(security, bts.spark.Order.AlgoOrderTypeOneofCase.LimitOrder); } - public static Order Order(Security security, Order.AlgoOrderTypeOneofCase algo_type) { + public static Order Order(SecurityImmutable security) { return Order(security, bts.spark.Order.AlgoOrderTypeOneofCase.LimitOrder); } + public static Order Order(SecurityImmutable security, Order.AlgoOrderTypeOneofCase algo_type) { var rv = new Order { Account = ImportedResources.Accounts.FirstOrDefault(), User = ImportedResources.UserName, - Security = security, + Security = security.CloneToMutable(), }; switch (algo_type) { case bts.spark.Order.AlgoOrderTypeOneofCase.LimitOrder: rv.LimitOrder = new LimitOrder(); break; diff --git a/src/client/spark/mspark/Utilities/SecurityDataHelper.cs b/src/client/spark/mspark/Utilities/SecurityDataHelper.cs index 7b351eba8..3119c69cf 100644 --- a/src/client/spark/mspark/Utilities/SecurityDataHelper.cs +++ b/src/client/spark/mspark/Utilities/SecurityDataHelper.cs @@ -6,13 +6,13 @@ using static bts.api.Security; namespace mbts.spark { - public static class SecurityDataHelper + static class SecurityDataHelper { public static class Comparer { - public static readonly IComparer Instance = Comparer.Create(Compare); + public static readonly IComparer Instance = Comparer.Create(Compare); - public static int Compare(Security x, Security y) { + public static int Compare(SecurityImmutable x, SecurityImmutable y) { if (x == null) return y == null ? 0 : -1; if (y == null) return 1; if (x.ContractCase == ContractOneofCase.Future) return y.ContractCase == ContractOneofCase.Future ? Compare(x.Symbol, x.Future, y.Symbol, y.Future) : -1; @@ -35,7 +35,7 @@ namespace mbts.spark return xlegs.Length.CompareTo(ylegs.Length); } - public static int Compare(string x_sym, FutureContract x, string y_sym, FutureContract y) { + public static int Compare(string x_sym, FutureContractImmutable x, string y_sym, FutureContractImmutable y) { int sym_comp = x_sym.CompareTo(y_sym); return sym_comp == 0 ? x.RawExpDate().CompareTo(y.RawExpDate()) : sym_comp; } diff --git a/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs b/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs index c4bfb6513..68a9d3c3a 100644 --- a/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs +++ b/src/client/spark/mspark/Utilities/SyntheticDataHelper.cs @@ -130,16 +130,16 @@ namespace mbts.spark.utilities public static PostHedgeTimeBasedForcedCross PostHedgeTimeBasedForcedCross => new PostHedgeTimeBasedForcedCross(); #endregion - public static Security Security(string name, Security from) { + public static Security Security(string name, SecurityImmutable from) { Security rv = null; switch(from.ContractCase) { case bts.api.Security.ContractOneofCase.Spread: - var legs = from.Spread.Legs.ToList(); - rv = from.Clone(); + var legs = from.Spread.Legs.Select(l => l.CloneToMutable()).ToList(); + rv = from.CloneToMutable(); rv.Synthetic = SyntheticContract(name, legs); break; case bts.api.Security.ContractOneofCase.Synthetic: - rv = from.Clone(); + rv = from.CloneToMutable(); rv.Synthetic.Name = name; break; default: throw new ArgumentException("Must be a Synthetic, or Spread.", nameof(from)); @@ -147,7 +147,7 @@ namespace mbts.spark.utilities rv.Id = 0; return rv; } - public static Security Security(string name, IEnumerable securities) { return Security(name, securities.Select(ContractLeg), MathUtils.GCD(securities.Select(s => s.ContractSpec.LowTick))); } + public static Security Security(string name, IEnumerable securities) { return Security(name, securities.Select(ContractLeg), MathUtils.GCD(securities.Select(s => s.ContractSpec.LowTick))); } public static Security Security(string name, IEnumerable legs, double tick_size) { return new Security { Id = 0, @@ -166,18 +166,18 @@ namespace mbts.spark.utilities foreach (var l in legs) rv.Legs.Add(l); return rv; } - public static ContractLeg ContractLeg(Security security) { - return new ContractLeg { Security = security, PriceMultiplier = 1, Quantity = 1, Side = Side.Buy }; + public static ContractLeg ContractLeg(SecurityImmutable security) { + return new ContractLeg { Security = security.CloneToMutable(), PriceMultiplier = 1, Quantity = 1, Side = Side.Buy }; } - public static ExecutionStrategy ExecutionStrategy(Security security) { + public static ExecutionStrategy ExecutionStrategy(SecurityImmutable security) { switch(security.ContractCase) { case bts.api.Security.ContractOneofCase.Spread: return ExecutionStrategy(security.Spread.Legs.Select(l => l.Security)); case bts.api.Security.ContractOneofCase.Synthetic: return ExecutionStrategy(security.Synthetic.Legs.Select(l => l.Security)); default: throw new ArgumentException("Must be a Spread, or Synthetic", nameof(security)); } } - public static ExecutionStrategy ExecutionStrategy(IEnumerable securities) { return ExecutionStrategy(securities.Select(s => s.Id)); } + public static ExecutionStrategy ExecutionStrategy(IEnumerable securities) { return ExecutionStrategy(securities.Select(s => s.Id)); } public static ExecutionStrategy ExecutionStrategy(IEnumerable security_keys) { var rv = new ExecutionStrategy(); foreach (var sk in security_keys) rv.LegParamsMap.Add(sk, LegSpreaderParams); diff --git a/src/client/spark/sys/api/SecurityConverter.cs b/src/client/spark/sys/api/SecurityConverter.cs index 861a913e5..9904a3b7d 100644 --- a/src/client/spark/sys/api/SecurityConverter.cs +++ b/src/client/spark/sys/api/SecurityConverter.cs @@ -4,7 +4,7 @@ namespace bts.api { static class SecurityConverter { - public static SecurityType security_type(this Security security) { + public static SecurityType security_type(this SecurityImmutable security) { switch (security.ContractCase) { case ContractOneofCase.Future: return SecurityType.Future; case ContractOneofCase.Spread: return SecurityType.Spread; diff --git a/src/client/spark/sys/api/Test/ApiTests.cs b/src/client/spark/sys/api/Test/ApiTests.cs index d7e80b17a..d67fac92d 100644 --- a/src/client/spark/sys/api/Test/ApiTests.cs +++ b/src/client/spark/sys/api/Test/ApiTests.cs @@ -72,7 +72,7 @@ namespace mbts.api.Test { var h = _context.locate(); TableUpdate last_update = null; - using (var sub1 = h.subscribe_greetings().table().Subscribe(t => last_update = t)) { + using (var sub1 = h.subscribe_greetings().Table().Subscribe(t => last_update = t)) { var response = h.say_hello(new HelloRequest() { Name = "UnitTest 1" }); Assert.AreEqual("Hello UnitTest 1", response.Message); diff --git a/src/client/spark/sys/api/Test/HelloServiceServer.cs b/src/client/spark/sys/api/Test/HelloServiceServer.cs index c956fbf9b..d63762126 100644 --- a/src/client/spark/sys/api/Test/HelloServiceServer.cs +++ b/src/client/spark/sys/api/Test/HelloServiceServer.cs @@ -31,10 +31,10 @@ namespace bts.api.core var resp = await _shout.upper_async(new ShoutRequest() { Msg = msg }); // Yell so loud you can't hear the last message _gpub.publish( - added: new List { new HelloLog() { Myid = (++id).ToString(), Message = resp.result.MSG } }, + added: new List { new HelloLog() { Myid = (++id).ToString(), Message = resp.value.MSG } }, removed: new HashSet { (id - 1).ToString() }); switch (resp.success) { - case true: return new HelloResponse() { Message = resp.result.MSG }; + case true: return new HelloResponse() { Message = resp.value.MSG }; default: return new HelloResponse() { Message = "Sorry {0}. We cannot yell at you right now.".fmt(request.Name) }; } } diff --git a/src/client/spark/sys/persist/UISettings.cs b/src/client/spark/sys/persist/UISettings.cs index 564f9940d..242d12a87 100644 --- a/src/client/spark/sys/persist/UISettings.cs +++ b/src/client/spark/sys/persist/UISettings.cs @@ -50,9 +50,9 @@ namespace mbts.persist Ns = uns(ns), Key = { key } }); - check_error(ret.result.Result, ns, key, out bool empty); + check_error(ret.value.Result, ns, key, out bool empty); if (empty) return default(T); - return deserialize(ret.result.Record.Single().Value); + return deserialize(ret.value.Record.Single().Value); } private Google.Protobuf.ByteString serialize(T obj) { @@ -90,9 +90,9 @@ namespace mbts.persist new RetrieveAllRequest() { Ns = uns(ns) }); - check_error(results.result.Result, ns, "", out bool empty); + check_error(results.value.Result, ns, "", out bool empty); if (empty) return Enumerable.Empty>(); - return results.result.Record + return results.value.Record .Where(r => re.IsMatch(r.Key)) .Select(r => new PersistResult() { user = user(), diff --git a/src/client/spark/uicore/Settings/UserPersistFactory.cs b/src/client/spark/uicore/Settings/UserPersistFactory.cs index 834af30b7..1d0504b9e 100644 --- a/src/client/spark/uicore/Settings/UserPersistFactory.cs +++ b/src/client/spark/uicore/Settings/UserPersistFactory.cs @@ -25,8 +25,8 @@ namespace mbts.ui.settings } async Task get_users(UserService login) { - var users = await login.get_logins_async(null); - if (users.success) return users.result.Login.ToArray(); + var users = await login.get_users_async(null); + if (users.success) return users.value.Users.Select(x => x.Login).ToArray(); else return new string[0]; } diff --git a/src/client/spark/uicore/Shell/Login/LoginModel.cs b/src/client/spark/uicore/Shell/Login/LoginModel.cs index 687935878..04ec1e89a 100644 --- a/src/client/spark/uicore/Shell/Login/LoginModel.cs +++ b/src/client/spark/uicore/Shell/Login/LoginModel.cs @@ -103,9 +103,9 @@ namespace mbts.ui.shell _logon = users; // Populate the UI _enum_workspace = new PreloginWorkspaceEnumerator(persist); - var response = await _logon.get_logins_async(new GetLoginsRequest()); + var response = await _logon.get_users_async(new GetUsersRequest()); if (response.success) { - UserNames = response.result.Login.ToArray(); + UserNames = response.value.Users.Select(x => x.Login).ToArray(); Array.Sort(UserNames); } else { @@ -127,13 +127,13 @@ namespace mbts.ui.shell Password = password ??"" }); if (response.success) { - if (response.result.IsValid) { + if (response.value.IsValid) { _workspace = workspace; set_authenticated_user(username); return (true, ""); } else { - return (false, response.result.Reason); + return (false, response.value.Reason); } } else { diff --git a/src/client/spark/view/Controls/PriceEntryControl.xaml.cs b/src/client/spark/view/Controls/PriceEntryControl.xaml.cs index 11ab946c8..cf7ae26c4 100644 --- a/src/client/spark/view/Controls/PriceEntryControl.xaml.cs +++ b/src/client/spark/view/Controls/PriceEntryControl.xaml.cs @@ -19,7 +19,7 @@ namespace mbts.ui.spark #region Value public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", typeof(double), typeof(PriceEntryControl),new FrameworkPropertyMetadata(double.NaN, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault, null, CoerceValue)); - private static object CoerceValue(DependencyObject d, object baseValue) { return TickUtils.get_regional_ticks((ContractSpecification)d.GetValue(ContractSpecProperty)).round((double)baseValue); } + private static object CoerceValue(DependencyObject d, object baseValue) { return TickUtils.get_regional_ticks((ContractSpecificationImmutable)d.GetValue(ContractSpecProperty)).round((double)baseValue); } public double Value { get => (double)GetValue(ValueProperty); set => SetValue(ValueProperty, value); } #endregion @@ -36,9 +36,9 @@ namespace mbts.ui.spark #endregion #region ContractSpec - public static readonly DependencyProperty ContractSpecProperty = DependencyProperty.Register("ContractSpec", typeof(ContractSpecification), typeof(PriceEntryControl), new PropertyMetadata(TickUtils.DefaultSpec, OnContractSpecChanged)); + public static readonly DependencyProperty ContractSpecProperty = DependencyProperty.Register("ContractSpec", typeof(ContractSpecificationImmutable), typeof(PriceEntryControl), new PropertyMetadata(TickUtils.DefaultSpec, OnContractSpecChanged)); private static void OnContractSpecChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { ((PriceEntryControl)d)._update_text_binding(); } - public ContractSpecification ContractSpec { get => GetValue(ContractSpecProperty) as ContractSpecification; set => SetValue(ContractSpecProperty, value); } + public ContractSpecificationImmutable? ContractSpec { get => GetValue(ContractSpecProperty) as ContractSpecificationImmutable?; set => SetValue(ContractSpecProperty, value); } #endregion public PriceEntryControl() { @@ -48,8 +48,8 @@ namespace mbts.ui.spark private TextBox _text; - private void _tick_up() { SetCurrentValue(ValueProperty, ContractSpec.tickup(Value)); } - private void _tick_down() { SetCurrentValue(ValueProperty, ContractSpec.tickdown(Value)); } + private void _tick_up() { SetCurrentValue(ValueProperty, ContractSpec.HasValue ? ContractSpec.Value.tickup(Value) : Value); } + private void _tick_down() { SetCurrentValue(ValueProperty, ContractSpec.HasValue ? ContractSpec.Value.tickdown(Value) : Value); } private void _update_text_binding() { if (_text != null) { diff --git a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs index b086e203f..0760c39cb 100644 --- a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs +++ b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityCollectionView.cs @@ -12,7 +12,7 @@ using static bts.api.Security; namespace mbts.ui.spark { - public partial class SecuritySelectorControl : Control { + partial class SecuritySelectorControl : Control { internal class SecurityCollectionView : ListCollectionView { public SecurityCollectionView(IList list) : base(list) { } private ReadOnlyObservableCollection _base_groups; @@ -79,7 +79,7 @@ namespace mbts.ui.spark private bool _suspended; private void _cvg_IsAllSelectedChanged() { if(!_suspended) _refresh_is_all_selected(); } - private void _sec_IsSelectedChanged(Security security, bool is_selected) { if (!_suspended) _refresh_is_all_selected(); } + private void _sec_IsSelectedChanged(SecurityImmutable security, bool is_selected) { if (!_suspended) _refresh_is_all_selected(); } private void _refresh_is_all_selected() { bool? new_ias = _get_is_all_selected(); diff --git a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs index d85941db4..f34a27712 100644 --- a/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs +++ b/src/client/spark/view/Controls/SecuritySelectorControl/SecurityItem.cs @@ -6,15 +6,15 @@ using static bts.api.Security; namespace mbts.ui.spark { - public partial class SecuritySelectorControl : Control { + partial class SecuritySelectorControl : Control { internal class SecurityItem : ViewModelBase, ISelectable { - public SecurityItem(Security security, bool is_selected) { + public SecurityItem(SecurityImmutable security, bool is_selected) { this.security = security; _is_selected = is_selected; } private bool _is_selected; - public Security security { get; private set; } + public SecurityImmutable security { get; private set; } public Venue exchange => security.Exchange; public ContractOneofCase type => security.ContractCase; public string symbol => security.ForceSymbol(); @@ -30,7 +30,7 @@ namespace mbts.ui.spark } } } - public event Action IsSelectedChanged; + public event Action IsSelectedChanged; public override int GetHashCode() { return security.Id.GetHashCode(); } } } diff --git a/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs b/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs index 0894e5693..bb101b732 100644 --- a/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs +++ b/src/client/spark/view/Controls/SecuritySelectorControl/SecuritySelectorControl.xaml.cs @@ -12,48 +12,45 @@ using System.Windows.Data; namespace mbts.ui.spark { - /// - /// Interaction logic for SecuritySelectorControl.xaml - /// - public partial class SecuritySelectorControl : Control + partial class SecuritySelectorControl : Control { static SecuritySelectorControl() { DefaultStyleKeyProperty.OverrideMetadata(typeof(SecuritySelectorControl), new FrameworkPropertyMetadata(typeof(SecuritySelectorControl))); } public SecuritySelectorControl() { - SetCurrentValue(SecuritiesProperty, new ObservableCollection()); - SetCurrentValue(SelectedSecuritiesProperty, new ObservableCollection()); + SetCurrentValue(SecuritiesProperty, new ObservableCollection()); + SetCurrentValue(SelectedSecuritiesProperty, new ObservableCollection()); } public static readonly DependencyProperty SelectionModeProperty = DependencyProperty.Register("SelectionMode", typeof(SelectionMode), typeof(SecuritySelectorControl), new PropertyMetadata(SelectionMode.Multiple)); public SelectionMode SelectionMode { get => (SelectionMode)GetValue(SelectionModeProperty); set => SetValue(SelectionModeProperty, value); } #region Securities - public static readonly DependencyProperty SecuritiesProperty = DependencyProperty.Register("Securities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSecuritiesChanged)); + public static readonly DependencyProperty SecuritiesProperty = DependencyProperty.Register("Securities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSecuritiesChanged)); private static void OnSecuritiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { - var securities = e.NewValue as ObservableCollection; + var securities = e.NewValue as ObservableCollection; if (securities != null) { var target = (SecuritySelectorControl)d; - target.InternalSecurityItems = new ObservableAutoWrapper(securities, target._create_security_item); + target.InternalSecurityItems = new ObservableAutoWrapper(securities, target._create_security_item); } } - private SecurityItem _create_security_item(Security s) { + private SecurityItem _create_security_item(SecurityImmutable s) { var selected_securities = SelectedSecurities; var item = new SecurityItem(s, selected_securities != null && selected_securities.Contains(s)); item.IsSelectedChanged += _internal_security_item_IsSelectedChanged; return item; } - public ObservableCollection Securities { get => GetValue(SecuritiesProperty) as ObservableCollection; set => SetValue(SecuritiesProperty, value); } + public ObservableCollection Securities { get => GetValue(SecuritiesProperty) as ObservableCollection; set => SetValue(SecuritiesProperty, value); } #endregion #region SelectedSecurities - public static readonly DependencyProperty SelectedSecuritiesProperty = DependencyProperty.Register("SelectedSecurities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSelectedSecuritiesChanged)); + public static readonly DependencyProperty SelectedSecuritiesProperty = DependencyProperty.Register("SelectedSecurities", typeof(ObservableCollection), typeof(SecuritySelectorControl), new PropertyMetadata(null, OnSelectedSecuritiesChanged)); private static void OnSelectedSecuritiesChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var target = (SecuritySelectorControl)d; - var old_val = e.OldValue as ObservableCollection; + var old_val = e.OldValue as ObservableCollection; if (old_val != null) old_val.CollectionChanged -= target.SelectedSecurities_CollectionChanged; - var new_val = e.NewValue as ObservableCollection; + var new_val = e.NewValue as ObservableCollection; if (new_val != null) { target._selected_securities_changing = true; foreach (var item in target.InternalSecurityItems) item.is_selected = new_val.Contains(item.security); @@ -67,8 +64,8 @@ namespace mbts.ui.spark _selected_securities_changing = true; var items = InternalSecurityItems; switch (e.Action) { - case NotifyCollectionChangedAction.Add: foreach (Security s in e.NewItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = true); break; - case NotifyCollectionChangedAction.Remove: foreach (Security s in e.OldItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = false); break; + case NotifyCollectionChangedAction.Add: foreach (SecurityImmutable s in e.NewItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = true); break; + case NotifyCollectionChangedAction.Remove: foreach (SecurityImmutable s in e.OldItems) items.ApplyToFirst(si => si.security.Equals(s), si => si.is_selected = false); break; default: var selected_securities = SelectedSecurities; foreach (SecurityItem si in items) si.is_selected = selected_securities.Contains(si.security); @@ -77,7 +74,7 @@ namespace mbts.ui.spark _selected_securities_changing = false; } } - public ObservableCollection SelectedSecurities { get => GetValue(SelectedSecuritiesProperty) as ObservableCollection; set => SetValue(SelectedSecuritiesProperty, value); } + public ObservableCollection SelectedSecurities { get => GetValue(SelectedSecuritiesProperty) as ObservableCollection; set => SetValue(SelectedSecuritiesProperty, value); } #endregion #region InternalSecurityItems @@ -96,7 +93,7 @@ namespace mbts.ui.spark } } private void _internal_security_items_ViewDestroyed(SecurityItem item) { item.IsSelectedChanged -= _internal_security_item_IsSelectedChanged; } - private void _internal_security_item_IsSelectedChanged(Security security, bool is_selected) { + private void _internal_security_item_IsSelectedChanged(SecurityImmutable security, bool is_selected) { if (!_selected_securities_changing) { _selected_securities_changing = true; if (is_selected) SelectedSecurities.Add(security); diff --git a/src/client/spark/view/Converters/TickDisplayConverter.cs b/src/client/spark/view/Converters/TickDisplayConverter.cs index 7f7a05aa1..309499636 100644 --- a/src/client/spark/view/Converters/TickDisplayConverter.cs +++ b/src/client/spark/view/Converters/TickDisplayConverter.cs @@ -13,7 +13,7 @@ namespace mbts.ui.spark.converters public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture) { var price = (double)values[0]; if (HideNaN && double.IsNaN(price)) return string.Empty; - var spec = (ContractSpecification)values[1]; + var spec = (ContractSpecificationImmutable)values[1]; return spec.format(price); } @@ -25,16 +25,16 @@ namespace mbts.ui.spark.converters internal class TickDisplayTwoWayConverter : IValueConverter { public bool HideNaN { get; set; } - public ContractSpecification ContractSpec { get; set; } = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; + public ContractSpecificationImmutable? ContractSpec { get; set; } = new ContractSpecification { CashPerPoint = 1.0, LowTick = 0.01, HighTick = 0.01, PriceBreak = double.MaxValue, PriceMultiplier = 1.0 }; public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { var price = (double)value; if (HideNaN && double.IsNaN(price)) return string.Empty; - return ContractSpec.format(price); + return ContractSpec.Value.format(price); } public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { - return ContractSpec.parse(value as string); + return ContractSpec.Value.parse(value as string); } } } \ No newline at end of file diff --git a/src/client/spark_api/api/Channels/QuickBusClientChannel.cs b/src/client/spark_api/api/Channels/QuickBusClientChannel.cs index 7570d645e..3d777658c 100644 --- a/src/client/spark_api/api/Channels/QuickBusClientChannel.cs +++ b/src/client/spark_api/api/Channels/QuickBusClientChannel.cs @@ -50,18 +50,18 @@ namespace bts.api.core { return tcs.Task; } - public unsafe override IObservable> subscribe(string method_and_qualifier, MessageParser parser) { + public unsafe override IObservable> subscribe(string method_and_qualifier, MessageParser parser, Func converter) { bool first_update = true; - var result = Observable.Create>(observer => { + var result = Observable.Create>(observer => { ApiNativeMethods.raw_subscription_callback cb = (event_type, changes, change_count, unused) => { if (event_type == ApiNativeMethods.EventType.TABLE_UPDATED) { - var added_items = new List(change_count); + var added_items = new List(change_count); var added_keys = new List(change_count); var removed_keys = new List(change_count); foreach (var change in changes) { if (change.type != ApiNativeMethods.ChangeType.REMOVE) { // create or change - added_items.Add(parser.ParseFrom(new UnmanagedMemoryStream(change.buffer, change.buffer_len))); + added_items.Add( converter( parser.ParseFrom(new UnmanagedMemoryStream(change.buffer, change.buffer_len)))); added_keys.Add(change.key); } if (change.type != ApiNativeMethods.ChangeType.CREATE) { @@ -69,11 +69,11 @@ namespace bts.api.core { removed_keys.Add(change.key); } } - observer.OnNext(new RawUpdate(added_items, added_keys, removed_keys)); + observer.OnNext(new RawUpdate(added_items, added_keys, removed_keys)); } else if (event_type == ApiNativeMethods.EventType.TABLE_CREATED) { if (!first_update) { - observer.OnNext(RawUpdate.Reset()); + observer.OnNext(RawUpdate.Reset()); } first_update = false; } diff --git a/src/client/spark_api/api/ClientChannel.cs b/src/client/spark_api/api/ClientChannel.cs index f727f6a0e..003c4ff5a 100644 --- a/src/client/spark_api/api/ClientChannel.cs +++ b/src/client/spark_api/api/ClientChannel.cs @@ -1,21 +1,21 @@ -using Google.Protobuf; -using System; -using System.Threading.Tasks; - -namespace bts.api.core { - internal abstract class ClientChannel : IDisposable +using Google.Protobuf; +using System; +using System.Threading.Tasks; + +namespace bts.api.core { + internal abstract class ClientChannel : IDisposable { readonly ServiceContext _context; public ClientChannel(ServiceContext context) { _context = context; - } - public abstract void Dispose(); - public abstract Task> send(int method_id, Request request) + } + public abstract void Dispose(); + public abstract Task> send(int method_id, Request request) where Request: IImmutableMessage where Response : class,IMessage,new(); - public abstract IObservable> subscribe(string method_and_qualifier, MessageParser parser) - where T : IMessage; - - public abstract bool is_sync_call_ok(); - } -} + public abstract IObservable> subscribe(string method_and_qualifier, MessageParser parser, Func converter=null) + where TParse : IMessage; + + public abstract bool is_sync_call_ok(); + } +} diff --git a/src/client/spark_api/api/Result.cs b/src/client/spark_api/api/Result.cs index 85aae5151..b77386675 100644 --- a/src/client/spark_api/api/Result.cs +++ b/src/client/spark_api/api/Result.cs @@ -3,44 +3,44 @@ using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; - -namespace bts.api.core -{ - - public struct Result - { - public Result(T v) { - _result = v; - _code = ApiError.Success; - } - public Result(ApiError code) { - System.Diagnostics.Debug.Assert(code != ApiError.Success); - _code = code; - _result = default(T); - } - - private string error_string(ApiError code) { - switch (code) { - case ApiError.Success: return "Success"; - case ApiError.NoServer: return "No server found."; - case ApiError.ServerDisconnect: return "Server disconnected."; - case ApiError.MissingMethod: return "Method not found."; - case ApiError.ServerFault: return "Server error."; - default: return "Unknown error"; - } - } - - readonly T _result; - readonly ApiError _code; - - public T result { - get { - if (success) return _result; - else throw new ApiException(error_message); - } - } - public bool success { get { return _code == ApiError.Success; } } - public ApiError code { get { return _code; } } - public string error_message { get { return error_string(_code); } } - } -} + +namespace bts.api.core +{ + + public struct Result + { + public Result(T v) { + _result = v; + _code = ApiError.Success; + } + public Result(ApiError code) { + System.Diagnostics.Debug.Assert(code != ApiError.Success); + _code = code; + _result = default(T); + } + + private string error_string(ApiError code) { + switch (code) { + case ApiError.Success: return "Success"; + case ApiError.NoServer: return "No server found."; + case ApiError.ServerDisconnect: return "Server disconnected."; + case ApiError.MissingMethod: return "Method not found."; + case ApiError.ServerFault: return "Server error."; + default: return "Unknown error"; + } + } + + readonly T _result; + readonly ApiError _code; + + public T value { + get { + if (success) return _result; + else throw new ApiException(error_message); + } + } + public bool success { get { return _code == ApiError.Success; } } + public ApiError code { get { return _code; } } + public string error_message { get { return error_string(_code); } } + } +} diff --git a/src/client/spark_api/api/Update.cs b/src/client/spark_api/api/Update.cs index c704708d2..8342dd17b 100644 --- a/src/client/spark_api/api/Update.cs +++ b/src/client/spark_api/api/Update.cs @@ -1,85 +1,85 @@ -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using System.Reactive.Linq; - -namespace bts.api.core { - - public struct RawUpdate { - // RawUpdate uses List instead of IReadonlyList to avoid virtual dispatch on a type not likely to be see in a public api surface - public RawUpdate(List added_items, List added_keys, List removed_keys) : this() { - is_reset = false; - this.added_items = added_items; - this.added_keys = added_keys; - this.removed_keys = removed_keys; - } - - public static RawUpdate Reset() { - return new RawUpdate() { is_reset = true }; - } - +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Reactive.Linq; - public bool is_reset; - public List added_items { get; private set; } - public List added_keys { get; private set; } - public List removed_keys { get; private set; } - } - - public class Update where TKey : IEquatable { - private Func _key; - public Update(IEnumerable all, IReadOnlyList added, IReadOnlyList removed, Func key_extractor) { - this.added = added; - this.removed = removed; - this.all = all; - _key = key_extractor; - } - - public IEnumerable all { get; private set; } - public IReadOnlyList added { get; private set; } - public IReadOnlyList removed { get; private set; } - - public TKey key(T t) { return _key(t); } - } - - public class TableUpdate where TKey : IEquatable { - - readonly Dictionary _state; - readonly IReadOnlyList _added; - readonly IReadOnlyList _removed; - - internal TableUpdate(Dictionary init, IReadOnlyList added, IReadOnlyList removed) { - _state = init; - _added = added; - _removed = removed; - } - - public IReadOnlyDictionary state { get { return _state; } } - public IReadOnlyList added { get { return _added; } } - public IReadOnlyList removed { get { return _removed; } } - - public TableUpdate update(Update update) { - var table = new TableUpdate(new Dictionary(_state), update.added, update.removed); - foreach (var i in update.removed) { - table._state.Remove(update.key(i)); - } - foreach (var item in update.added) { - table._state.Add(update.key(item), item); - } - return table; - } - } - - public static class ObservableUpdateExtensions { - public static IObservable> reconstitute(this IObservable> source, Func key_extractor) where TKey : IEquatable { - var state = new Dictionary(); - return source.Select(raw => { +namespace bts.api.core { + + public struct RawUpdate { + // RawUpdate uses List instead of IReadonlyList to avoid virtual dispatch on a type not likely to be see in a public api surface + public RawUpdate(List added_items, List added_keys, List removed_keys) : this() { + is_reset = false; + this.added_items = added_items; + this.added_keys = added_keys; + this.removed_keys = removed_keys; + } + + public static RawUpdate Reset() { + return new RawUpdate() { is_reset = true }; + } + + + public bool is_reset; + public List added_items { get; private set; } + public List added_keys { get; private set; } + public List removed_keys { get; private set; } + } + + public class Update where TKey : IEquatable { + private Func _key; + public Update(IReadOnlyCollection all, IReadOnlyList added, IReadOnlyList removed, Func key_extractor) { + this.added = added; + this.removed = removed; + this.all = all; + _key = key_extractor; + } + + public IReadOnlyCollection all { get; private set; } + public IReadOnlyList added { get; private set; } + public IReadOnlyList removed { get; private set; } + + public TKey key(T t) { return _key(t); } + } + + public class TableUpdate where TKey : IEquatable { + + readonly Dictionary _state; + readonly IReadOnlyList _added; + readonly IReadOnlyList _removed; + + internal TableUpdate(Dictionary init, IReadOnlyList added, IReadOnlyList removed) { + _state = init; + _added = added; + _removed = removed; + } + + public IReadOnlyDictionary state { get { return _state; } } + public IReadOnlyList added { get { return _added; } } + public IReadOnlyList removed { get { return _removed; } } + + public TableUpdate update(Update update) { + var table = new TableUpdate(new Dictionary(_state), update.added, update.removed); + foreach (var i in update.removed) { + table._state.Remove(update.key(i)); + } + foreach (var item in update.added) { + table._state.Add(update.key(item), item); + } + return table; + } + } + + public static class ObservableUpdateExtensions { + public static IObservable> reconstitute(this IObservable> source, Func key_extractor) where TKey : IEquatable { + var state = new Dictionary(); + return source.Select(raw => { if (raw.is_reset) { var removed = state.Values.ToList(); state.Clear(); return new Update(new T[0], new T[0], removed, key_extractor); - } + } else { var removed = new List(raw.removed_keys.Count); foreach (var r in raw.removed_keys) { @@ -93,14 +93,14 @@ namespace bts.api.core { state[raw.added_keys[x]] = raw.added_items[x]; } return new Update(state.Values, raw.added_items, removed, key_extractor); - } - }); - } - - public static IObservable> table(this IObservable> source) where TKey : IEquatable { - return source.Scan( - new TableUpdate(new Dictionary(), new List(), new List()), - (table, update) => table.update(update)); - } - } -} + } + }); + } + + public static IObservable> Table(this IObservable> source) where TKey : IEquatable { + return source.Scan( + new TableUpdate(new Dictionary(), new List(), new List()), + (table, update) => table.update(update)); + } + } +} diff --git a/src/client/spark_api/security/Security.cs b/src/client/spark_api/security/Security.cs index 6af51346c..04c517a40 100644 --- a/src/client/spark_api/security/Security.cs +++ b/src/client/spark_api/security/Security.cs @@ -4,11 +4,12 @@ using System.Collections.Generic; using System.Linq; using static bts.api.SecurityFormatter; using static bts.api.Security; +using security_key = System.UInt32; namespace bts.api { public partial class Security : IFormattable { - private static readonly PartFormattingTuple[] _standard_format = new[] { + internal static readonly PartFormattingTuple[] _standard_format = new[] { new PartFormattingTuple(ContractParts.Name, "!"), new PartFormattingTuple(ContractParts.Quantity), new PartFormattingTuple(ContractParts.Symbol, "."), @@ -19,34 +20,49 @@ namespace bts.api { return Format(this, string.IsNullOrEmpty(format) ? _standard_format : Parse(format)); } + internal static readonly Security Empty = new Security { + Exchange = Venue.Bts, + ContractSpec = new ContractSpecification { CashPerPoint = double.NaN, HighTick = double.NaN, LowTick = double.NaN, PriceBreak = double.NaN, PriceMultiplier = double.NaN } + }; + + public static security_key key(Security s) { return s.Id; } + } + + partial struct SecurityImmutable : IComparable { + public int CompareTo(SecurityImmutable other) { + return Id.CompareTo(other.Id); + } + public string ToString(string format, IFormatProvider formatProvider=null) { + return Format(this, string.IsNullOrEmpty(format) ? _standard_format : Parse(format)); + } + + partial void EqualsOverride(ref bool didrun, ref bool result, SecurityImmutable other) { + didrun = true; + result = Id == other.Id; + } + /// /// Traverses the security to get the leaf /// exchange securities /// /// - public IEnumerable> get_base_exchange_securities () + internal IEnumerable> get_base_exchange_securities () { List> rv = new List> (); get_base_exchange_securities (this, Side.Buy, 1.0, ref rv); return rv; } - - private static void get_base_exchange_securities (Security sec, Side side, double mult, ref List> legs) + private static void get_base_exchange_securities (SecurityImmutable sec, Side side, double mult, ref List> legs) { Func resolve_side = (s1, s2) => ((s1 == Side.Buy ? 1 : -1) * (s2 == Side.Buy ? 1 : -1)) == 1 ? Side.Buy : Side.Sell; if (sec.ContractCase == ContractOneofCase.Future) legs.Add (Tuple.Create (sec.Id, side, mult)); else if (sec.ContractCase == ContractOneofCase.Spread) - foreach (ContractLeg leg in sec.Spread.Legs) + foreach (ContractLegImmutable leg in sec.Spread.Legs) get_base_exchange_securities (leg.Security, resolve_side (side, leg.Side), leg.Quantity * mult, ref legs); else if (sec.ContractCase == ContractOneofCase.Synthetic) - foreach (ContractLeg leg in sec.Synthetic.Legs) + foreach (ContractLegImmutable leg in sec.Synthetic.Legs) get_base_exchange_securities (leg.Security, resolve_side (side, leg.Side), leg.Quantity * mult, ref legs); } - - public static readonly Security Empty = new Security { - Exchange = Venue.Bts, - ContractSpec = new ContractSpecification { CashPerPoint = double.NaN, HighTick = double.NaN, LowTick = double.NaN, PriceBreak = double.NaN, PriceMultiplier = double.NaN } - }; } } \ No newline at end of file diff --git a/src/client/spark_api/security/SecurityFormatter.cs b/src/client/spark_api/security/SecurityFormatter.cs index fb5a501de..1b028bc15 100644 --- a/src/client/spark_api/security/SecurityFormatter.cs +++ b/src/client/spark_api/security/SecurityFormatter.cs @@ -2,7 +2,7 @@ using System; using System.Collections.Generic; using System.Linq; -using FutureLeg = System.Tuple; +using FutureLeg = System.Tuple; namespace bts.api { @@ -16,7 +16,7 @@ namespace bts.api }).ToList(); } - public static string Format(Security s, IEnumerable parts) { + public static string Format(SecurityImmutable s, IEnumerable parts) { var part_formatters = parts.Select(p => PartFormatterFactory.get_formatter(p)).ToList(); switch(s.ContractCase) { case Security.ContractOneofCase.Future: return _format_future(s, part_formatters); @@ -52,11 +52,11 @@ namespace bts.api } } - private static string _format_future(Security s, IEnumerable part_formatters) { return _format(s, part_formatters, _add_future); } + private static string _format_future(SecurityImmutable s, IEnumerable part_formatters) { return _format(s, part_formatters, _add_future); } private static string _format_future_leg(FutureLeg l, IEnumerable part_formatters) { return _format(l, part_formatters, _add_future_leg); } private delegate bool AddPart(T t, IPartFormatter part_formatter, out string result); - private static bool _add_future(Security s, IPartFormatter part_formatter, out string result) { return part_formatter.add_part(s, out result); } + private static bool _add_future(SecurityImmutable s, IPartFormatter part_formatter, out string result) { return part_formatter.add_part(s, out result); } private static bool _add_future_leg(FutureLeg l, IPartFormatter part_formatter, out string result) { return part_formatter.add_part(l, out result); } private static string _format(T t, IEnumerable part_formatters, AddPart add_part) { @@ -77,7 +77,7 @@ namespace bts.api { string separator { get; } bool add_part(FutureLeg fl, out string result); - bool add_part(Security s, out string result); + bool add_part(SecurityImmutable s, out string result); } private static class PartFormatterFactory @@ -122,7 +122,7 @@ namespace bts.api result = null; return false; } - public bool add_part(Security s, out string result) { + public bool add_part(SecurityImmutable s, out string result) { if (s.ContractCase == Security.ContractOneofCase.Synthetic) { result = s.Synthetic.Name; return true; @@ -150,7 +150,7 @@ namespace bts.api } return true; } - public bool add_part(Security s, out string result) { + public bool add_part(SecurityImmutable s, out string result) { result = null; return false; } @@ -161,24 +161,24 @@ namespace bts.api } public string separator { get; } public bool add_part(FutureLeg fl, out string result) { result = fl.Item2; return true; } - public bool add_part(Security s, out string result) { result = s.Symbol; return true; } + public bool add_part(SecurityImmutable s, out string result) { result = s.Symbol; return true; } } private class Formatter : IPartFormatter { - public Formatter(Func get_sec_value, Func get_leg_value, string separator) : this(get_sec_value, get_leg_value, t => t.ToString(), separator) { } - public Formatter(Func get_sec_value, Func get_leg_value, Func format, string separator) { + public Formatter(Func get_sec_value, Func get_leg_value, string separator) : this(get_sec_value, get_leg_value, t => t.ToString(), separator) { } + public Formatter(Func get_sec_value, Func get_leg_value, Func format, string separator) { _get_sec_value = get_sec_value; _get_leg_value = get_leg_value; _format = format; _separator = separator; } - private readonly Func _get_sec_value; + private readonly Func _get_sec_value; private readonly Func _get_leg_value; private readonly Func _format; private readonly string _separator; private T _last_val; public string separator => _separator ?? string.Empty; - public bool add_part(Security s, out string result) { + public bool add_part(SecurityImmutable s, out string result) { T val = _get_sec_value(s); if (!val.Equals(_last_val)) { result = _format(_last_val = val); diff --git a/src/client/spark_api/security/SecurityHelper.cs b/src/client/spark_api/security/SecurityHelper.cs index b20796afc..674bc67cc 100644 --- a/src/client/spark_api/security/SecurityHelper.cs +++ b/src/client/spark_api/security/SecurityHelper.cs @@ -3,14 +3,14 @@ using System; using System.Collections.Generic; using System.Linq; using static bts.api.Security; -using FutureLeg = System.Tuple; +using FutureLeg = System.Tuple; namespace bts.api { internal static class SecurityHelper { #region Private Members - private static IEnumerable _get_flat_future_legs(RepeatedField legs, int qty) { + private static IEnumerable _get_flat_future_legs(IEnumerable legs, int qty) { foreach (var l in legs) { switch (l.Security.ContractCase) { case ContractOneofCase.Future: yield return new FutureLeg(l.Security.Exchange, l.Security.Symbol, l.Security.Future, qty * l.SignedQuantity()); break; @@ -26,7 +26,7 @@ namespace bts.api } #endregion - public static IEnumerable get_flat_future_legs(Security sec) { + public static IEnumerable get_flat_future_legs(SecurityImmutable sec) { switch (sec.ContractCase) { case ContractOneofCase.Spread: return _get_flat_future_legs(sec.Spread.Legs, 1); case ContractOneofCase.Synthetic: return _get_flat_future_legs(sec.Synthetic.Legs, 1); @@ -37,21 +37,21 @@ namespace bts.api public static readonly IEqualityComparer IDEqualityComparer = new InternalIDEqualityComparer(); #region Extensions - public static DateTime RawExpDate(this FutureContract future) { return new DateTime((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay); } + public static DateTime RawExpDate(this FutureContractImmutable future) { return new DateTime((int)future.ExpirationYear, (int)future.ExpirationMonth, (int)future.ExpirationDay); } // TODO: Remove (probably do not need MappedExpDates in spark) - public static DateTime MappedExpDate(this FutureContract future) { + internal static DateTime MappedExpDate(this FutureContractImmutable future) { return RawExpDate(future); } - public static int SignedQuantity(this ContractLeg leg) { return leg.Side == Side.Buy ? (int)leg.Quantity : -(int)leg.Quantity; } + internal static int SignedQuantity(this ContractLegImmutable leg) { return leg.Side == Side.Buy ? (int)leg.Quantity : -(int)leg.Quantity; } - public static string ForceSymbol(this Security security) { + internal static string ForceSymbol(this SecurityImmutable security) { if (security.ContractCase == ContractOneofCase.Synthetic) return ForceSymbol(security.Synthetic.Legs.First().Security); else return security.Symbol; } - public static string DisplayExchange(this Security security) { + public static string DisplayExchange(this SecurityImmutable security) { return security.ContractCase == ContractOneofCase.Synthetic ? $"[{string.Join(",", get_flat_future_legs(security).Select(flt => flt.Item1.ToString()).Distinct().OrderBy(e => e))}]" : security.Exchange.ToString(); } #endregion diff --git a/src/client/spark_api/utils/IImmutableProto.cs b/src/client/spark_api/utils/IImmutableMessage.cs similarity index 94% rename from src/client/spark_api/utils/IImmutableProto.cs rename to src/client/spark_api/utils/IImmutableMessage.cs index 7764789ec..72d30f57e 100644 --- a/src/client/spark_api/utils/IImmutableProto.cs +++ b/src/client/spark_api/utils/IImmutableMessage.cs @@ -7,7 +7,7 @@ using System.Linq; using System.Text; using System.Threading.Tasks; -namespace bts { +namespace bts.api { internal interface IImmutableMessage { MessageDescriptor Descriptor { get; } int CalculateSize(); diff --git a/src/client/sparkcmd/Program.cs b/src/client/sparkcmd/Program.cs index 3d6d25e8f..bd373e3ca 100644 --- a/src/client/sparkcmd/Program.cs +++ b/src/client/sparkcmd/Program.cs @@ -17,10 +17,16 @@ namespace sparkcmd var c = mbts.config.Configuration.get(); mbts.Logger.info(bts.log.Subsystem.gen, "hello"); var ctx = new bts.api.core.ServiceContext(); + var s = ctx.locate(); - bts.api.user.GetLoginsRequest r = new bts.api.user.GetLoginsRequest(); - var response = s.get_logins(r); - Console.WriteLine("{0}", response); + var r = new bts.api.user.GetUsersRequest(); + var resp = s.get_users(r); + Console.WriteLine("{0}", resp); + + var a = ctx.locate(); + var ra = new bts.api.account.GetAccountsRequest(); + var respa = a.get_accounts(ra); + Console.WriteLine("{0}", respa); } } } \ No newline at end of file diff --git a/src/client/sparkcmd/sparkcmd.csproj b/src/client/sparkcmd/sparkcmd.csproj index 53832b23f..538bf4aa3 100644 --- a/src/client/sparkcmd/sparkcmd.csproj +++ b/src/client/sparkcmd/sparkcmd.csproj @@ -16,5 +16,5 @@ - + diff --git a/src/lib/CMakeDeps.cmake b/src/lib/CMakeDeps.cmake index 7c8fae68d..e57b1d834 100644 --- a/src/lib/CMakeDeps.cmake +++ b/src/lib/CMakeDeps.cmake @@ -1 +1 @@ -set(sources api/apicore.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/services/ApiUnitTestService.proto;api/services/HelloService.proto;api/services/MarketDataRelay.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/UserService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/Account.conf;config/defaults/Executor.conf;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/User.conf;config/defaults/edge.conf;config/defaults/expiration_display_offset.conf;config/defaults/jetfix.conf;config/defaults/logging.conf;config/defaults/testkeys.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/Account.proto;config/protos/MarketData.proto;config/protos/Ports.proto;config/protos/Symbols.proto;config/protos/UI.proto;config/protos/User.proto;config/protos/environment.proto;config/protos/expiration_display_offset.proto;config/protos/jetfix.proto;config/protos/logging.proto;config/protos/quickbus_cfg.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/toggles.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain_model/Security.cpp;domain_model/Security.proto;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPriceLantencyTester.cpp;md/Diag/ShmDumper.cpp;md/MDConsumer.cpp;md/MDConsumerHandle.cpp;md/MDConsumerInterop.cpp;md/MDProducer.cpp;md/MDProducerHandle.cpp;md/MDRecoverableConsumer.cpp;md/MemorySegmentUtils.cpp;md/PlatformLoader.cpp;md/SecurityIDRecorder.cpp;md/SettlementRecorder.cpp;md/Structure/FixedSecurity.cpp;md/Structure/PriceSize.cpp;md/common.cpp;md/protos/co2.proto;md/relay/QueryServer.cpp;md/relay/RelayClient.cpp;md/relay/RelayRecorder.cpp;md/test/Co2TestInstrument.cpp;md/test/md2_tests.cpp;os/os.cpp;os/tests/os_tests.cpp;quickbus/core/LocalNode.cpp;quickbus/core/Quickbus.cpp;quickbus/core/SubscriptionID.cpp;quickbus/core/TableID.cpp;quickbus/message_model/Update.cpp;quickbus/message_model/merge_updates.cpp;quickbus/network/QBConnection.cpp;quickbus/network/QBConnectionManager.cpp;quickbus/network/endpoint_description.cpp;quickbus/network/quickbus_msgs.proto;quickbus/pubsub/TablePublisher.cpp;quickbus/pubsub/TableSubscriber.cpp;quickbus/pubsub/tests/qb_pubsub_tests.cpp;quickbus/routing/INode.cpp;quickbus/routing/NodeID.cpp;quickbus/routing/Router.cpp;quickbus/rpc/RPCClient.cpp;quickbus/rpc/RPCServer.cpp;quickbus/rpc/RPCSessionID.cpp;quickbus/rpc/rpc_utils.cpp;quickbus/rpc/tests/qb_rpc_tests.cpp;quickbus/tests/quickbus_tests.cpp;sparkproto/SparkProtos.proto;testing/windows_test_driver.cpp;utils/Dispatcher.cpp;utils/HTTPStream.cpp;utils/PBUtils.cpp;utils/Puid.cpp;utils/SharedMemory.cpp;utils/Sqlite_utils.cpp;utils/Uuid.cpp;utils/datetime.cpp;utils/download.cpp;utils/file_utils.cpp;utils/init_spark_lib.cpp;utils/is_unittest_environment.cpp) \ No newline at end of file +set(sources api/apicore.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/services/AccountService.proto;api/services/ApiUnitTestService.proto;api/services/HelloService.proto;api/services/MarketDataRelay.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/UserService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/Executor.conf;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/edge.conf;config/defaults/expiration_display_offset.conf;config/defaults/jetfix.conf;config/defaults/logging.conf;config/defaults/testkeys.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/MarketData.proto;config/protos/Ports.proto;config/protos/Symbols.proto;config/protos/UI.proto;config/protos/environment.proto;config/protos/expiration_display_offset.proto;config/protos/jetfix.proto;config/protos/logging.proto;config/protos/quickbus_cfg.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/toggles.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain_model/Security.cpp;domain_model/Security.proto;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPriceLantencyTester.cpp;md/Diag/ShmDumper.cpp;md/MDConsumer.cpp;md/MDConsumerHandle.cpp;md/MDConsumerInterop.cpp;md/MDProducer.cpp;md/MDProducerHandle.cpp;md/MDRecoverableConsumer.cpp;md/MemorySegmentUtils.cpp;md/PlatformLoader.cpp;md/SecurityIDRecorder.cpp;md/SettlementRecorder.cpp;md/Structure/FixedSecurity.cpp;md/Structure/PriceSize.cpp;md/common.cpp;md/protos/co2.proto;md/relay/QueryServer.cpp;md/relay/RelayClient.cpp;md/relay/RelayRecorder.cpp;md/test/Co2TestInstrument.cpp;md/test/md2_tests.cpp;os/os.cpp;os/tests/os_tests.cpp;quickbus/core/LocalNode.cpp;quickbus/core/Quickbus.cpp;quickbus/core/SubscriptionID.cpp;quickbus/core/TableID.cpp;quickbus/message_model/Update.cpp;quickbus/message_model/merge_updates.cpp;quickbus/network/QBConnection.cpp;quickbus/network/QBConnectionManager.cpp;quickbus/network/endpoint_description.cpp;quickbus/network/quickbus_msgs.proto;quickbus/pubsub/TablePublisher.cpp;quickbus/pubsub/TableSubscriber.cpp;quickbus/pubsub/tests/qb_pubsub_tests.cpp;quickbus/routing/INode.cpp;quickbus/routing/NodeID.cpp;quickbus/routing/Router.cpp;quickbus/rpc/RPCClient.cpp;quickbus/rpc/RPCServer.cpp;quickbus/rpc/RPCSessionID.cpp;quickbus/rpc/rpc_utils.cpp;quickbus/rpc/tests/qb_rpc_tests.cpp;quickbus/tests/quickbus_tests.cpp;sparkproto/SparkProtos.proto;testing/windows_test_driver.cpp;utils/Dispatcher.cpp;utils/HTTPStream.cpp;utils/PBUtils.cpp;utils/Puid.cpp;utils/SharedMemory.cpp;utils/Sqlite_utils.cpp;utils/Uuid.cpp;utils/datetime.cpp;utils/download.cpp;utils/file_utils.cpp;utils/init_spark_lib.cpp;utils/is_unittest_environment.cpp) \ No newline at end of file diff --git a/src/lib/CMakeLists.txt b/src/lib/CMakeLists.txt index d7408ce0a..880aeb643 100644 --- a/src/lib/CMakeLists.txt +++ b/src/lib/CMakeLists.txt @@ -114,3 +114,4 @@ if (WIN32) endif() + diff --git a/src/lib/api/service_compiler/plugin.py b/src/lib/api/service_compiler/plugin.py index cc6360676..a91288c2a 100755 --- a/src/lib/api/service_compiler/plugin.py +++ b/src/lib/api/service_compiler/plugin.py @@ -77,11 +77,19 @@ EnumModel = namedtuple("EnumModel", "name values") def transform_enum(e): return EnumModel(e.name, []) -MessageModel = namedtuple("MessageModel", "name field nested_type nested_enum") +OneofModel = namedtuple("OneofModel", "name Name") +def transform_oneof(o, msg): + return OneofModel( + name = o.name, + Name = o.name[0].upper() + o.name[1:] + ) + +MessageModel = namedtuple("MessageModel", "name field oneof nested_type nested_enum") def transform_message(i): r = MessageModel( name = i.name, field = [transform_field(f,i) for f in i.field], + oneof = [transform_oneof(o,i) for o in i.oneof_decl], nested_type = [transform_message(m) for m in i.nested_type], nested_enum = [transform_enum(e) for e in i.enum_type], ) @@ -98,12 +106,11 @@ def transform_service(service, keymap): FileModel = namedtuple("FileModel", "name package namespace_csharp message_type service enum_type") def transform_file(p, keymap): - message_types = [transform_message(m) for m in p.message_type] return FileModel( name = p.name, package = p.package, namespace_csharp = p.package, - message_type = message_types, + message_type = [transform_message(m) for m in p.message_type], service = [transform_service(s, keymap) for s in p.service], enum_type = [transform_enum(e) for e in p.enum_type] ) @@ -206,7 +213,6 @@ def generate_insertions(params, request, response): def camel_case(item): if item.isupper() and not '_' in item: return item return item.title().replace('_', '') - return d def generate_code(request, response): diff --git a/src/lib/api/service_compiler/templates/c#/client.pb.cs b/src/lib/api/service_compiler/templates/c#/client.pb.cs index d1af51ae8..3a35cea45 100644 --- a/src/lib/api/service_compiler/templates/c#/client.pb.cs +++ b/src/lib/api/service_compiler/templates/c#/client.pb.cs @@ -20,20 +20,37 @@ public sealed class {{name}} : IApiClient, IDisposable { {{#if server_streaming}} // {{comment}} public IObservable> subscribe_{{name}}({{input_type_full}} qualifier=null) { - return _channel.subscribe<{{output_type_full}}>(ApiServer.format_qualifier("{{name}}",qualifier), {{output_type_full}}.Parser).reconstitute(key); + return _channel.subscribe<{{output_type_full}}, {{output_type_full}}>(ApiServer.format_qualifier("{{name}}",qualifier), {{output_type_full}}.Parser, a=>a).reconstitute(key); + } + internal IObservable> subscribei_{{name}}({{input_type_full}} qualifier=null) { + return _channel.subscribe<{{output_type_full}}, {{output_type_full}}Immutable>(ApiServer.format_qualifier("{{name}}",qualifier), {{output_type_full}}.Parser, a=>({{output_type_full}}Immutable)a).reconstitute(key); } private static {{key_type.cstype}} key({{output_type_full}} row) { return row.{{camel key_field}}; } + private static {{key_type.cstype}} key({{output_type_full}}Immutable row) { + return row.{{camel key_field}}; + } {{else}} // {{comment}} public Task> {{name}}_async({{input_type_full}} request) { return _channel.send<{{input_type_full}},{{output_type_full}}>({{@index}}, request); } + internal Task> {{name}}_async({{input_type_full}}Immutable request) { + return _channel.send<{{input_type_full}}Immutable,{{output_type_full}}>({{@index}}, request); + } // {{comment}} public {{output_type_full}} {{name}}({{input_type_full}} request) { if (_channel.is_sync_call_ok()) { - return {{name}}_async(request).Result.result; + return {{name}}_async(request).Result.value; + } + else { + throw new bts.api.core.ApiException("API blocking call cannot be made on this thread. Please use {{name}}_async instead."); + } + } + internal {{output_type_full}} {{name}}({{input_type_full}}Immutable request) { + if (_channel.is_sync_call_ok()) { + return {{name}}_async(request).Result.value; } else { throw new bts.api.core.ApiException("API blocking call cannot be made on this thread. Please use {{name}}_async instead."); diff --git a/src/lib/api/service_compiler/templates/c#/immutable.pb.cs b/src/lib/api/service_compiler/templates/c#/immutable.pb.cs index 45eb3ca7c..1541c11ed 100644 --- a/src/lib/api/service_compiler/templates/c#/immutable.pb.cs +++ b/src/lib/api/service_compiler/templates/c#/immutable.pb.cs @@ -8,14 +8,14 @@ using Google.Protobuf.WellKnownTypes; namespace {{package}} { {{#each message_type}} - partial class {{name}} : bts.IImmutableMessage { - MessageDescriptor bts.IImmutableMessage.Descriptor => {{name}}.Descriptor; + partial class {{name}} : bts.api.IImmutableMessage { + MessageDescriptor bts.api.IImmutableMessage.Descriptor => {{name}}.Descriptor; } - partial struct {{name}}Immutable : bts.IImmutableMessage { + partial struct {{name}}Immutable : bts.api.IImmutableMessage { readonly {{name}} _impl; public static MessageDescriptor Descriptor => {{name}}.Descriptor; - MessageDescriptor bts.IImmutableMessage.Descriptor => {{name}}.Descriptor; + MessageDescriptor bts.api.IImmutableMessage.Descriptor => {{name}}.Descriptor; public int CalculateSize() => _impl.CalculateSize(); public void WriteTo(CodedOutputStream output) => _impl.WriteTo(output); @@ -42,8 +42,12 @@ namespace {{package}} { public bool Equals({{name}}Immutable other) { return _impl.Equals(other._impl); } + partial void EqualsOverride(ref bool didrun, ref bool result, {{name}}Immutable other); public bool Equals({{name}}Immutable? other) { if (other == null) return false; + bool didrun = false, result = false; + EqualsOverride(ref didrun, ref result, other.Value); + if (didrun) return result; return _impl.Equals(other.Value._impl); } public override int GetHashCode() => _impl.GetHashCode(); @@ -61,13 +65,18 @@ namespace {{package}} { {{else}} {{#if type.islist}} // Can remove the cast if immutable==cstype - public IEnumerable<{{type.immutable}}> {{Name}} => _impl.{{Name}}.Cast<{{type.immutable}}>(); + public IEnumerable<{{type.immutable}}> {{Name}} => _impl.{{Name}}.Select(t => ({{type.immutable}})t); {{else}} public {{type.immutable}} {{Name}} => ({{type.immutable}})_impl.{{Name}}; {{/if}} {{/if}} {{/each}} + + // oneof enums + {{#each oneof}} + public {{../name}}.{{Name}}OneofCase {{Name}}Case => _impl.{{Name}}Case; + {{/each}} public {{name}}Immutable with( // Arguments diff --git a/src/lib/api/services/AccountService.proto b/src/lib/api/services/AccountService.proto new file mode 100644 index 000000000..217473e6c --- /dev/null +++ b/src/lib/api/services/AccountService.proto @@ -0,0 +1,50 @@ +syntax="proto3"; +package bts.api.account; +option csharp_namespace="bts.api.account"; +import "lib/api/apioptions.proto"; +import "lib/api/services/UserService.proto"; + +message RiskLimit { + uint32 max_order_size = 10; + uint32 max_position_long = 20; + uint32 max_position_short = 30; + uint32 max_position_net = 40; +} + +message AccountBalance { + double cash_position = 10; + double leverage_factor = 20; +} + +message Account { + string tag1 = 10; + bool can_trade = 20; + AccountBalance balance = 30; + + repeated bts.api.user.OperatorID allowed_operators = 100; + map future_limits = 110; + map spread_limits = 120; +} + +message GetAccountsRequest {} +message GetAccountsResponse {repeated Account accounts = 1;} +message AddOrUpdateAccountRequest {bts.api.user.AuthToken token = 1; Account account = 2;} +message RemoveAccountRequest {bts.api.user.AuthToken token = 1; string tag1 = 2;} +message UpdateAccountBalanceRequest {string tag1 = 2; AccountBalance new_balance = 3;} +message AccountOperationResponse {bool is_valid = 1; string reason = 2; } + +service AccountService { + option (bts.api.service_description) = "Provides a management interface to the system account list"; + + rpc get_accounts(GetAccountsRequest) returns (GetAccountsResponse) + {option (bts.api.method_description)="Returns list of valid accounts";} + + rpc add_or_update_account(AddOrUpdateAccountRequest) returns (AccountOperationResponse) + {option (bts.api.method_description)="Adds or Updates an Account";} + + rpc remove_account(RemoveAccountRequest) returns (AccountOperationResponse) + {option (bts.api.method_description)="Removes an Account";} + + rpc update_account_balance(UpdateAccountBalanceRequest) returns (AccountOperationResponse) + {option (bts.api.method_description)="Updates account balance without affecting limits or registered operators";} +} diff --git a/src/lib/api/services/UserService.proto b/src/lib/api/services/UserService.proto index 9457f9af2..7685e3dc1 100644 --- a/src/lib/api/services/UserService.proto +++ b/src/lib/api/services/UserService.proto @@ -3,18 +3,52 @@ package bts.api.user; option csharp_namespace="bts.api.user"; import "lib/api/apioptions.proto"; -message GetLoginsRequest {} -message GetLoginsRespose {repeated string login = 1;} +message OperatorID { string tag50 = 10; } -message AuthenticateLoginRequest {string login = 1; string password = 2;} -message AuthenticateLoginResponse {bool is_valid = 1; string reason = 2;} +message Operator { + OperatorID operator_id = 10; + bool can_trade = 20; +} + +enum UserType { USERTYPE_NORMAL = 0; USERTYPE_ADMIN = 1;} + +message User { + string login = 1; + string password = 2; + UserType user_type = 10; + repeated Operator operators = 100; +} + +message AuthToken { + string token = 1; +} + +message GetUsersRequest {} +message GetUsersResponse {repeated User users = 1;} +message AddOrUpdateUserRequest {AuthToken token = 1; User user = 2;} +message RemoveUserRequest {AuthToken token = 1; string login = 2;} +message UserOperationResponse { bool is_valid = 1; string reason = 2;} + +message AuthenticateLoginRequest {string login = 1; string password = 2;} +message AuthenticateLoginResponse {bool is_valid = 1; string reason = 2; AuthToken token = 3;} +message AuthenticateTokenRequest {AuthToken token = 1;} +message AuthenticateTokenResponse {bool is_valid = 1; string reason = 2; User user = 3;} service UserService { - option (bts.api.service_description) = "Provides access to the system user list"; + option (bts.api.service_description) = "Provides a management interface to the system user list"; - rpc get_logins(GetLoginsRequest) returns (GetLoginsRespose) - {option (bts.api.method_description)="Returns list of valid logins";} - - rpc authenticate_login(AuthenticateLoginRequest) returns (AuthenticateLoginResponse) - {option (bts.api.method_description)="Returns wheter the login/password combination is valid";} + rpc authenticate_login(AuthenticateLoginRequest) returns (AuthenticateLoginResponse) + {option (bts.api.method_description)="Returns wheter the login/password combination is valid and a 'Authorization Token' used for further API calls";} + + rpc authenticate_token(AuthenticateTokenRequest) returns (AuthenticateTokenResponse) + {option (bts.api.method_description)="Returns user for a specific AuthToken, if valid";} + + rpc get_users(GetUsersRequest) returns (GetUsersResponse) + {option (bts.api.method_description)="Returns list of valid users";} + + rpc add_or_update_user(AddOrUpdateUserRequest) returns (UserOperationResponse) + {option (bts.api.method_description)="Adds or Updates a user";} + + rpc remove_user(RemoveUserRequest) returns (UserOperationResponse) + {option (bts.api.method_description)="Removes a user";} } diff --git a/src/lib/config/defaults/Account.conf b/src/lib/config/defaults/Account.conf deleted file mode 100644 index f7995375b..000000000 --- a/src/lib/config/defaults/Account.conf +++ /dev/null @@ -1,64 +0,0 @@ -AccountCfg -{ - value - { - accounts_with_limits - { - account - { - account_id: 'TAG1' - can_trade: true - cash_position: 1000000.0 - leverage_factor: 1.0 - allowed_operators - { - id: 'TAG50' - } - } - future_limits - { - key: 'ES' - value - { - max_order_size: 100 - max_position_long: 1000 - max_position_short: 1000 - max_position_net: 1000 - } - } - future_limits - { - key: 'GC' - value - { - max_order_size: 100 - max_position_long: 1000 - max_position_short: 1000 - max_position_net: 1000 - } - } - spread_limits - { - key: 'ES' - value - { - max_order_size: 100 - max_position_long: 1000 - max_position_short: 1000 - max_position_net: 1000 - } - } - spread_limits - { - key: 'GC' - value - { - max_order_size: 100 - max_position_long: 1000 - max_position_short: 1000 - max_position_net: 1000 - } - } - } - } -} \ No newline at end of file diff --git a/src/lib/config/defaults/User.conf b/src/lib/config/defaults/User.conf deleted file mode 100644 index 6eb5727e1..000000000 --- a/src/lib/config/defaults/User.conf +++ /dev/null @@ -1,25 +0,0 @@ -UserCfg -{ - value - { - user { login: "bts" password: "" } - user { login: "bts2" password: "bts2" } - user - { - login: 'bts3' - password: '' - is_admin: true - - operators - { - operator_id { id: 'TAG50' } - can_trade: true - } - operators - { - operator_id { id: 'TAG50_' } - can_trade: true - } - } - } -} \ No newline at end of file diff --git a/src/lib/config/protos/Account.proto b/src/lib/config/protos/Account.proto deleted file mode 100644 index c7c08af71..000000000 --- a/src/lib/config/protos/Account.proto +++ /dev/null @@ -1,34 +0,0 @@ -syntax='proto2'; -package bts.config; - -import "lib/config/protos/User.proto"; - -message RiskLimit -{ - optional uint32 max_order_size = 10; - optional uint32 max_position_long = 20; - optional uint32 max_position_short = 30; - optional uint32 max_position_net = 40; -} - -message Account -{ - optional string account_id = 10; //tag 1 - optional bool can_trade = 15; - optional double cash_position = 20; - optional double leverage_factor = 30; - - repeated OperatorID allowed_operators = 100; -} - -message AccountWithLimits -{ - optional Account account = 10; - map future_limits = 20; - map spread_limits = 30; -} - -message AccountCfg -{ - repeated AccountWithLimits accounts_with_limits = 10; -} diff --git a/src/lib/config/protos/User.proto b/src/lib/config/protos/User.proto deleted file mode 100644 index 1e7365642..000000000 --- a/src/lib/config/protos/User.proto +++ /dev/null @@ -1,27 +0,0 @@ -syntax='proto2'; -package bts.config; - -message OperatorID -{ - optional string id = 10; //tag 50, 18 bytes limit -} - -message Operator -{ - optional OperatorID operator_id = 10; - optional bool can_trade = 20; -} - -message User -{ - required string login = 1; - optional string password = 2; - optional bool is_admin = 10; - - repeated Operator operators = 100; -} - -message UserCfg -{ - repeated User user = 1; -} diff --git a/src/lib/sparkproto/SparkProtos.proto b/src/lib/sparkproto/SparkProtos.proto index e4da1bda7..5e4be4e30 100644 --- a/src/lib/sparkproto/SparkProtos.proto +++ b/src/lib/sparkproto/SparkProtos.proto @@ -29,7 +29,7 @@ message Order { } TimeInForce time_in_force = 50; uint64 timestamp = 60; - oneof algo_order_type { + oneof AlgoOrderType { MarketOrder market_order = 100; LimitOrder limit_order = 110; StopMarketOrder stop_market_order = 120; @@ -144,7 +144,7 @@ message BTSShootTillHitOrder /// Only support a limit or market as Retry's /// We can make Retry a general parameter for /// every order - oneof native_order_type + oneof NativeOrderType { MarketOrder market_order = 10; LimitOrder limit_order = 20; @@ -171,7 +171,7 @@ message BTSWithATickParameters message BTSWithATickOrder { BTSWithATickParameters order_parameters = 10; - oneof native_order_type + oneof NativeOrderType { LimitOrder limit_order = 20; } @@ -202,7 +202,7 @@ message BTSTimedWindowParameters message BTSTimedWindowOrder { BTSTimedWindowParameters order_parameters = 10; - oneof native_order_type + oneof NativeOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; @@ -245,12 +245,12 @@ When the market penetrates the trigger price, a limit order is sent "payup" tick message BTSStopOrder { PriceTrigger price_trigger = 10; - oneof native_trigger_order_type + oneof NativeTriggerOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; } - oneof trigger_order_price + oneof TriggerOrderPrice { PriceOffset payup = 40; double price = 50; @@ -269,12 +269,12 @@ Opposite of BTS Stop (Both in terms of where the order is placed, and how it tra message BTSIfTouchedOrder { PriceTrigger price_trigger = 10; - oneof native_trigger_order_type + oneof NativeTriggerOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; } - oneof order_price + oneof OrderPrice { PriceOffset payup = 40; double price = 50; @@ -293,7 +293,7 @@ previous has been filled. message BTSIcebergOrder { QuantityMeasure display_quantity = 10; - oneof child_order_offset + oneof ChildOrderOffset { PriceOffset market_offset = 20; double diff_from_last_fill = 30; @@ -312,7 +312,7 @@ message BTSTimeSliceOrder { double interval = 10; QuantityMeasure display_quantity = 20; - oneof child_order_type + oneof ChildOrderType { MarketOrder market_order = 30; LimitOrder limit_order = 40; @@ -320,7 +320,7 @@ message BTSTimeSliceOrder PriceOffset child_order_offset = 50; /// the earlier order can either be left, or its /// price moved toward the inside market by payup_ticks - oneof left_over_action + oneof LeftOverAction { bool leave = 60; double payup_ticks = 70; @@ -343,12 +343,12 @@ ii. If the stop order is trigerred, the Limit order is cancelled message BTSOCOOrder { PriceTrigger price_trigger = 10; - oneof native_trigger_order_type + oneof NativeTriggerOrderType { MarketOrder market_order = 20; LimitOrder limit_order = 30; } - oneof order_price + oneof OrderPrice { PriceOffset payup = 40; double price = 50; diff --git a/src/server/sparkd/CMakeDeps.cmake b/src/server/sparkd/CMakeDeps.cmake index 2273b9f4e..2a17b4936 100644 --- a/src/server/sparkd/CMakeDeps.cmake +++ b/src/server/sparkd/CMakeDeps.cmake @@ -1 +1 @@ -set(sources ;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/Market.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/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.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/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.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/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/UserServiceServer.cpp) \ No newline at end of file +set(sources ;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/TestOrderman.cpp;event_grid/EventNode.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/Market.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/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.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/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp;orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/tests/spreader_order_tests.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/SingleFillHedger.cpp;spreader/SingleLegQuoter.cpp;spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;testing/catch_test_runner.cpp;user/AccountServiceServer.cpp;user/UserServiceServer.cpp;user/tests/UserAndAccountTests.cpp) \ No newline at end of file diff --git a/src/server/sparkd/CMakeLists.txt b/src/server/sparkd/CMakeLists.txt index 950a4ea89..5fa5cb8b8 100644 --- a/src/server/sparkd/CMakeLists.txt +++ b/src/server/sparkd/CMakeLists.txt @@ -41,6 +41,4 @@ target_link_libraries( sparkd # copy test data file(COPY jetfix/tests/sample_fix.dat DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/test_data) - - - + \ No newline at end of file diff --git a/src/server/sparkd/cmds/Run.cpp b/src/server/sparkd/cmds/Run.cpp index a12235b76..b3e4ee555 100644 --- a/src/server/sparkd/cmds/Run.cpp +++ b/src/server/sparkd/cmds/Run.cpp @@ -11,6 +11,7 @@ #include "server/sparkd/persistence/PersistenceServiceServer.h" #include "server/sparkd/user/UserServiceServer.h" +#include "server/sparkd/user/AccountServiceServer.h" #include "server/sparkd/md/run_md.h" #include "server/sparkd/orderman/service/OrderServiceServer.h" #include "server/sparkd/exchange_sim/ExchangeSim.h" @@ -35,6 +36,7 @@ int Run::execute(std::vector const &) persistence::PersistenceServiceServer settings_saver(sc,"settings"); user::UserServiceServer login_server(sc); + account::AccountServiceServer account_server(sc); md::run_market_datapublishers(); md::QueryServerPtr md_query_server(md::run_query_server(sc)); orderman::OrderServiceServer order_server(sc); diff --git a/src/server/sparkd/orderman/components/Gateway.cpp b/src/server/sparkd/orderman/components/Gateway.cpp index 45f3c9e60..ca1b4dc31 100644 --- a/src/server/sparkd/orderman/components/Gateway.cpp +++ b/src/server/sparkd/orderman/components/Gateway.cpp @@ -45,7 +45,10 @@ Gateway::Gateway(config::JetFIX::Connection const&c, securities::SecurityDB &db) " able to process it. This might lead to lost fills and should " " be investigated",sk.value()); else { - + // ignore leg fills, we care only about the actual security fill + if (msg.has() && msg.get() == 2) + return; + std::string reject_msg; if (msg.has()) reject_msg = msg.get(); diff --git a/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h b/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h index 54aefdf17..8b37e49e9 100644 --- a/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/ISpreaderStateWorker.h @@ -1,20 +1,22 @@ #pragma once - +#include "lib/utils/bts_chrono.h" #include "lib/domain_model/Security.pb.h" #include "lib/api/services/OrderService.pb.h" #include "lib/sparkproto/SparkProtos.pb.h" #include "server/sparkd/orderman/utils/orderman_utils.h" #include "server/sparkd/spreader/SpreaderLegData.h" // fix this (not needed) +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h" namespace bts { namespace orderman { class SpreaderOrder; -class TimeStamp; class Book; class ISpreaderStateWorker { public: virtual void build_once (SpreaderOrder* spreader_order) = 0; + virtual SpreaderState state() const = 0; + virtual const std::string& state_text () const = 0; //virtual SpreaderOrder::State state() const = 0; // called once and only once, before any other calls. // the spreaderoder will be in the start stat diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp index 18c8bb7ea..03feae2b7 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.cpp @@ -8,277 +8,167 @@ #include "server/sparkd/spreader/LegPropertyData.h" #include "server/sparkd/spreader/SpreaderLegData.h" #include "server/sparkd/spreader/SpreaderBookkeepingData.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h" -#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h" namespace bts { namespace orderman { - -struct SpreaderOrder::PImpl -{ - PImpl(bool resurrected_arg, - const api::orderman::CreateOrderRequest& create_order_request_arg, - securities::ISecurityDB& db_arg, - OrderKey order_key, - api::orderman::OrderStatus status, - Price price, - Quantity quantity, - std::string const &reject_msg) - : - resurrected (resurrected_arg), - state (State::START), - create_order_request (create_order_request_arg), - db (db_arg), - report_message (ReportMessage (order_key, status, price, quantity, reject_msg)) - {} - const bool resurrected; - State state; - const api::orderman::CreateOrderRequest create_order_request; - securities::ISecurityDB& db; - SpreaderBookkeepingData bookkeeping_data; - ReportMessage report_message; - ISpreaderStateWorker* state_worker; - SpreaderStartStateWorker start_state_worker; - SpreaderWaitingForFirstConnStateWorker waiting_for_first_conn_state_worker; - SpreaderWorkingStateWorker working_state_worker; - SpreaderWaitingForCancelAllStateWorker waiting_for_cancel_all_state_worker; - SpreaderEndStateWorker end_state_worker; -}; - SpreaderOrder::SpreaderOrder(securities::ISecurityDB &db, NativeOrderFactory &f, const api::orderman::OrderState& os) : SpreaderOrderBase(db, f, os), - me(new PImpl(true, api::orderman::CreateOrderRequest(), db, OrderKey (0), os.order_status(), - Price(os.spreader().price()), Quantity(os.spreader().quantity()), os.reject_msg())) + _active(false), + _create_order_request (api::orderman::CreateOrderRequest()), + _state_worker(nullptr) { - LOG(OrderMan, Diag, "recovered SpreaderOrder {} from disk",os.order_key() ); + LOG(OrderMan, Diag, "SpreaderOrder.cons recovered from disk, key: {}", os.order_key() ); } - SpreaderOrder::SpreaderOrder(securities::ISecurityDB& db, NativeOrderFactory& f, OrderKey k, const api::orderman::CreateOrderRequest& cor) : SpreaderOrderBase(db, f, k, cor), - me(new PImpl(false, cor, db, k, api::orderman::OS_UNACKNOWLEDGED, Price(cor.spreader().price()), - Quantity(cor.spreader().quantity()), std::string(""))) + _active (true), + _create_order_request (cor), + _state_worker(nullptr) { - LOG(OrderMan, Diag, "creating new SpreaderOrder. request: {}", utils::pb::to_string(cor)); + LOG(OrderMan, Diag, "SpreaderOrder.cons request: {} key: {}", utils::pb::to_string(cor), k.value()); bts_assert(cor.has_spreader()); bts_assert(cor.spreader().security().has_synthetic()); _transform_to_START (); } - -SpreaderOrder::~SpreaderOrder () {} +SpreaderOrder::~SpreaderOrder () {} void SpreaderOrder::init() { - if (me->resurrected) return; - LOG(OrderMan, Diag, "SpreaderOrder.Init"); - me->state_worker->init(); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.init key: {}", key().value()); + _state_worker->init(); } void SpreaderOrder::on_connect() { - if (me->resurrected) return; - LOG(OrderMan, Diag, "Spreaderorder.on_connect"); - me->state_worker->on_connect (); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_connect key: {}", key().value()); + _state_worker->on_connect (); } void SpreaderOrder::on_disconnect() { - if (me->resurrected) return; - LOG(OrderMan,Diag,"on_disconnect"); - me->state_worker->on_disconnect(); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_disconnect key: {}", key().value()); + _state_worker->on_disconnect(); } - void SpreaderOrder::on_update(const api::orderman::UpdateSpreaderOrder& u) { - LOG(OrderMan,Diag,"on_update SpreaderOrder: {}",key().value()); - if (me->resurrected) return; - me->state_worker->on_update(u); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_update key: {}", key().value()); + _state_worker->on_update(u); } - void SpreaderOrder::on_cancel(const api::orderman::CancelSpreaderOrder& c) { - LOG(OrderMan,Diag,"on_cancel SpreaderOrder. order {}",key().value()); - if (me->resurrected) return; - me->state_worker->on_cancel(c); + if (!_active) return; + LOG(OrderMan, Diag, "SpreaderOrder.on_cancel key: {}", key().value()); + _state_worker->on_cancel(c); } - void SpreaderOrder::on_book(TickToTradeCorID cid, Book const& book) { - if (me->resurrected) return; + if (!_active) return; LOG(Latency, Info, "on_book {} {}", cid, utils::TimeStamp::now().to_uint64()); - me->state_worker->on_book (cid, book); + _state_worker->on_book (cid, book); } - -void SpreaderOrder::on_time(const bts::TimeStamp&) +void SpreaderOrder::on_time(const bts::TimeStamp& ts) { - if (me->resurrected) return; + if (!_active) return; + _state_worker->on_time (ts); } - void SpreaderOrder::on_child_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const *error_msg) { - if (me->resurrected) return; + if (!_active) return; static std::string empty; - LOG(OrderMan,Diag, "SpreaderOrder.on_child_update " "k: {} status: {} filled_qty: {} avg_price: {} reject_msg: {}", + LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} status: {} filled_qty: {} avg_price: {} reject_msg: {}", order_key.value(), status, filled_quantity.value(), average_price.value(), error_msg == nullptr ? empty : *error_msg); - SpreaderLegData* leg_data_ptr = me->bookkeeping_data.find_leg_from_quoter_orderkey(order_key); + SpreaderLegData* leg_data_ptr = _bookkeeping_data.find_leg_from_quoter_orderkey(order_key); if (leg_data_ptr != nullptr) { SpreaderLegData& leg_data = *leg_data_ptr; - LOG(OrderMan,Diag, "Order {} is a quoting order, forwarding", order_key.value()); + LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} is a quoting order, forwarding", order_key.value()); if (error_msg != nullptr) - me->state_worker->on_quoter_order_error (leg_data, status, filled_quantity, average_price, error_msg); + _state_worker->on_quoter_order_error (leg_data, status, filled_quantity, average_price, error_msg); else { if (filled_quantity.value() != 0) - me->state_worker->on_quoter_order_fill (leg_data, status, filled_quantity, average_price); + _state_worker->on_quoter_order_fill (leg_data, status, filled_quantity, average_price); else - me->state_worker->on_quoter_order_status_update (leg_data, status); + _state_worker->on_quoter_order_status_update (leg_data, status); } } else { // should be a hedge order then - SpreaderHedgerData* hedger_data = me->bookkeeping_data.find_hedger_from_orderkey(order_key); + SpreaderHedgerData* hedger_data = _bookkeeping_data.find_hedger_from_orderkey(order_key); if (hedger_data != nullptr) { - LOG(OrderMan,Diag, "Order {} is a hedging order, forwarding", order_key.value()); + LOG(OrderMan,Diag, "SpreaderOrder.on_child_update key: {} is a hedging order, forwarding", order_key.value()); if (error_msg != nullptr) - me->state_worker->on_hedger_order_error (order_key, status, filled_quantity, average_price, error_msg); + _state_worker->on_hedger_order_error (order_key, status, filled_quantity, average_price, error_msg); else - me->state_worker->on_hedger_order_update (order_key, status, filled_quantity, average_price); + _state_worker->on_hedger_order_update (order_key, status, filled_quantity, average_price); } else - { - // uknown order, should be treater as an error condition bts_assert_msg (false, "This order was not initiated in this spreader"); - } } } - void SpreaderOrder::on_external_error(const std::string& reason) { - if (me->resurrected) return; + if (!_active) return; LOG(OrderMan,Warn, "on_external_error SpreaderOrder. msg: {}", reason); - me->state_worker->on_external_error (reason); + _state_worker->on_external_error (reason); } - const orderman::Book& SpreaderOrder::get_book(size_t leg_index) const { - return me->bookkeeping_data.get_leg_data(leg_index).book(); + return _bookkeeping_data.get_leg_data(leg_index).book(); } const LegPropertyData& SpreaderOrder::get_leg_data(size_t leg_index) const { - return me->bookkeeping_data.get_leg_data(leg_index).leg_property_data; + return _bookkeeping_data.get_leg_data(leg_index).leg_property_data; } - -void SpreaderOrder::_construct_bookkeeping_data_and_quoters() -{ - std::vector leg_data_vector; - //creating the basic data - ISpreaderManager& me_ref = *this; - const bts::api::orderman::CreateSpreaderOrder& cor = me->create_order_request.spreader(); - spark::ExecutionStrategy execution_strategy = cor.execution_strategy(); - const bts::api::Security& sec = cor.security(); - size_t leg_idx = 0; - for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) - { - // immutable property data for this leg - const bts::api::ContractLeg& leg = *it; - auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id()); - bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end()); - api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg); - LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side); - // setting up the order for this leg - bts::SecurityKey leg_key = bts::SecurityKey (leg_property_data.security_key()); - api::Security const* db_sec = me->db.resolve (leg_key); - bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(*db_sec, leg_property_data.trading_side, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); - bts::orderman::SpreaderOrderBase::ChildOrder child_order = child_factory(); - LOG(OrderMan,Diag,"Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), key().value()); - SingleLegQuoter leg_quoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order); - SpreaderLegData leg_data(leg_property_data, leg_quoter, child_order.order_key()); - leg_data_vector.push_back(leg_data); - leg_idx++; - } - bts_assert(leg_data_vector.size() > 0); - me->bookkeeping_data = SpreaderBookkeepingData(sec, leg_data_vector); -} - -void SpreaderOrder::_subscribe_to_marketdata() -{ - for (size_t index = 0; index < me->bookkeeping_data.count(); index++) - { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(index); - bts::SecurityKey leg_key = bts::SecurityKey (leg_data.leg_property_data.security_key()); - api::Security const* db_sec = me->db.resolve (leg_key); - subscribe_to_md (*db_sec); - } -} - -void SpreaderOrder::_init_quoters () -{ - for (size_t index = 0; index < me->bookkeeping_data.count(); index++) - { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(index); - if (leg_data.leg_property_data.is_active_quoting()) - leg_data.quoter().init(); - } -} - void SpreaderOrder::_transform_to_START() { - me->state = State::START; - me->state_worker = &(me->start_state_worker); - me->state_worker->build_once (this); - report_state (api::orderman::OrderStatus::OS_PENDING_NEW); + bts_assert (_state_worker == nullptr); + _switch_state (&_start_state_worker); + _report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } - void SpreaderOrder::_transform_to_WAITING_FOR_FIRST_CONNECTION() { - bts_assert(me->state == State::START); - me->state = State::WAITING_FOR_FIRST_CONNECT; - me->state_worker = &(me->waiting_for_first_conn_state_worker); - me->state_worker->build_once (this); - report_state (api::orderman::OrderStatus::OS_PENDING_NEW); + bts_assert(_state_worker->state() == SpreaderState::START); + _switch_state(&_waiting_for_first_conn_state_worker); + _report_state (api::orderman::OrderStatus::OS_PENDING_NEW); } void SpreaderOrder::_transform_to_WORKING() { - bts_assert(me->state == State::WAITING_FOR_FIRST_CONNECT); - me->state = State::WORKING; - me->state_worker = &(me->working_state_worker); - me->state_worker->build_once (this); - report_state (api::orderman::OrderStatus::OS_NEW); + bts_assert(_state_worker->state() == SpreaderState::WAITING_FOR_FIRST_CONNECT); + _switch_state(&_working_state_worker); + _report_state (api::orderman::OrderStatus::OS_NEW); } void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL() { - bts_assert(me->state == State::WORKING); - me->state = State::WAITING_FOR_CANCEL_ALL; - me->state_worker = &(me->waiting_for_cancel_all_state_worker); - me->state_worker->build_once (this); - report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); + bts_assert(_state_worker->state() == SpreaderState::WORKING); + _switch_state(&_waiting_for_cancel_all_state_worker); + _report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); } -void SpreaderOrder::_transform_to_END() +void SpreaderOrder::_transform_to_END(std::string* m) { - bts_assert(me->state == State::WORKING || me->state == State::WAITING_FOR_CANCEL_ALL); - me->state = State::END; - me->state_worker = &(me->end_state_worker); - me->state_worker->build_once (this); - report_state(); + bts_assert(_state_worker->state() != SpreaderState::END); + _switch_state(&_end_state_worker); + _report_state (api::orderman::OrderStatus::OS_DONE, m); } void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (cancel_quotes) { if (leg_data.leg_property_data.is_active_quoting()) @@ -294,9 +184,9 @@ void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) } bool SpreaderOrder::_all_quoter_orders_in_terminal_state() { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data.is_active_quoting()) if (!leg_data.quoter().is_terminal_state()) return false; @@ -306,9 +196,9 @@ bool SpreaderOrder::_all_quoter_orders_in_terminal_state() // same as _all_quoter_orders_in_terminal_state, for hedgers bool SpreaderOrder::_all_hedger_orders_in_terminal_state() { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) { SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); @@ -320,17 +210,17 @@ bool SpreaderOrder::_all_hedger_orders_in_terminal_state() } void SpreaderOrder::_terminate_quoters () { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); leg_data.quoter().terminate(); } } void SpreaderOrder::_terminate_hedgers () { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) { SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); @@ -340,99 +230,69 @@ void SpreaderOrder::_terminate_hedgers () } bool SpreaderOrder::_quoters_can_accept_modification () { - for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data.is_active_quoting()) if (!leg_data.quoter().accept_modifications()) return false; } return true; } - -void SpreaderOrder::_send_hedge(size_t, Price, Quantity, size_t) +void SpreaderOrder::_send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, + size_t hedge_leg_index) { -// for (size_t q_idx = 0; q_idx < me->bookkeeping_data.count(); q_idx++) -// { -// SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data(q_idx); -// for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) -// { -// SpreaderHedgerData& hedger_data = leg_data.get_hedger(h_idx); -// hedger_data.hed -// if (!hedger_data.hedger().is_terminal_state()) -// return false; -// } -// } + Price hedge_price; + Quantity hedge_quantity; + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data (hedge_leg_index); + _compute_hedge_price_quantity (filled_leg_index, filled_price, filled_quantity, hedge_leg_index, + hedge_price, hedge_quantity); + bts::orderman::SpreaderOrderBase::ChildOrder new_hedge_order = _get_new_order (leg_data.leg_property_data, false); + SpreaderHedgerData& hedger_data = leg_data.add_new_hedger (*this, new_hedge_order, hedge_price, hedge_quantity,leg_data.leg_property_data.trading_side); + hedger_data.hedger().init (); } void SpreaderOrder::_compute_hedge_price_quantity(size_t, Price, Quantity, size_t, Price&, Quantity&) { -} - -void SpreaderOrder::report_state() -{ -// report_state_change(SpreaderOrderState{ -// me->report_message.status, -// me->price, -// me->quantity, -// me->reject_msg.empty() ? nullptr : &me->reject_msg -// }); -} - -void SpreaderOrder::report_state (api::orderman::OrderStatus order_status) -{ - report_state_change(SpreaderOrderState{ - order_status, - me->report_message.price, - me->report_message.quantity, - nullptr - }); -} - -void SpreaderOrder::report_state (api::orderman::OrderStatus order_status, std::string& message) -{ -report_state_change(SpreaderOrderState{ - order_status, - me->report_message.price, - me->report_message.quantity, - message.empty() ? nullptr : &message - }); -} - -bool SpreaderOrder::can_resolve_securties () -{ - const bts::api::orderman::CreateSpreaderOrder& cor = me->create_order_request.spreader(); - const bts::api::Security& sec = cor.security(); - for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) + // 2 cases + if (_bookkeeping_data.count() == 2) + { + } + else { - const bts::api::ContractLeg& leg = *it; - bts::SecurityKey leg_key = bts::SecurityKey (leg.security().id()); - api::Security const * db_sec = me->db.resolve (leg_key); - if (db_sec == nullptr) - return false; } - return true; } - -void SpreaderOrder::update_spreader_order (Price price, Quantity quantity) +void SpreaderOrder::_report_state (api::orderman::OrderStatus order_status, std::string* m) { - me->report_message.price = price; - me->report_message.quantity = quantity; + report_state_change(SpreaderOrderState{ + order_status, + _bookkeeping_data.price(), + _bookkeeping_data.quantity(), + m + }); +} +void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state) +{ + LOG(OrderMan, Info, "SpreaderOrder::_switch_state key: {}, {} -> {} ", key().value(), (_state_worker == nullptr ? "NULL" : _state_worker->state_text()), new_state->state_text()); + _state_worker = new_state; + _state_worker->build_once (this); +} +bts::orderman::SpreaderOrderBase::ChildOrder SpreaderOrder::_get_new_order (const LegPropertyData& leg_property_data, bool is_quote_order) +{ + bts::SecurityKey sec_key = bts::SecurityKey (leg_property_data.security_key()); + api::Security const* db_sec = _db().resolve (sec_key); + api::orderman::ChildOrderKind order_type = is_quote_order ? api::orderman::ChildOrderKind::COK_SPREADER_QUOTING : api::orderman::ChildOrderKind::COK_SPREADER_HEDGING; + bts::orderman::SpreaderOrderBase::ChildFactory child_factory = get_child_factory(*db_sec, leg_property_data.trading_side, order_type); + return child_factory(); } - -SpreaderBookkeepingData& SpreaderOrder::bookkeeping_data () {return me->bookkeeping_data;} - /*******************************************************************************/ -/******************Functions to Help Testing************************************/ - -SpreaderOrder::State SpreaderOrder::test_only_func_state() {return me->state;} - +/***************************Functions to Help Testing****************************/ +SpreaderState SpreaderOrder::test_only_func_state() {return _state_worker->state();} SpreaderLegData& SpreaderOrder::test_only_func_leg_data (size_t index) { - SpreaderLegData& leg_data = me->bookkeeping_data.get_leg_data (index); + SpreaderLegData& leg_data = _bookkeeping_data.get_leg_data (index); return leg_data; } - -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h index 75676424c..0ba979561 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrder.h @@ -1,73 +1,40 @@ #pragma once #include +#include "lib/utils/bts_chrono.h" #include "lib/domain_model/Security.pb.h" #include "lib/api/services/OrderService.pb.h" #include "lib/sparkproto/SparkProtos.pb.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h" +#include "server/sparkd/securities/SecurityDB.h" #include "server/sparkd/spreader/SpreaderBookkeepingData.h" #include "server/sparkd/spreader/ISpreaderManager.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h" +#include "server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h" namespace bts { namespace api {namespace orderman {class OrderState; class CreateSpreaderOrder;}} -namespace securities {class SecurityDB;} +//namespace securities {class SecurityDB;} namespace orderman { class Book; class NativeOrderFactory; - class SpreaderOrder : public SpreaderOrderBase, public ISpreaderManager { public: - enum State - { - // pre init state - START, - // once init happens, it waits for the first connection - WAITING_FOR_FIRST_CONNECT, - // after the first connection, the general waiting state - WORKING, - // waiting for all quoters and hedgers to be done - WAITING_FOR_CANCEL_ALL, - // end state - END - }; - // state for the outgoing message is kept here. - // (could have been laid flat in the PImpl but this - // keeps the relevant data together) - // this mirrors the args of report_state_change - // call (except that the order_key is also piggybacked - // here since it belongs to the same family) - // - class ReportMessage - { - public: - const OrderKey order_key; - api::orderman::OrderStatus status; - Price price; - Quantity quantity; - std::string reject_msg; - ReportMessage (OrderKey order_key_arg, api::orderman::OrderStatus status_arg, - Price price_arg, Quantity quantity_arg, std::string reject_msg_arg) - : - order_key (order_key_arg), - status (status_arg), - price (price_arg), - quantity (quantity_arg), - reject_msg (reject_msg_arg) - {} - }; // old order recovered from disk SpreaderOrder(securities::ISecurityDB&, NativeOrderFactory&, api::orderman::OrderState const&); - // new order created by user SpreaderOrder(securities::ISecurityDB&, NativeOrderFactory&, OrderKey, api::orderman::CreateOrderRequest const&); - ~SpreaderOrder(); // called once and only once, before any other calls. // the spreaderoder will be in the start state @@ -87,7 +54,7 @@ public: void on_cancel(api::orderman::CancelSpreaderOrder const&); // on market data update (support late joiners) void on_book(TickToTradeCorID corid,Book const&); - void on_time(const TimeStamp&); + void on_time(const bts::TimeStamp&); // called whenever a child order updates, as long as the spreader // is not in a terminal state. void on_child_update(OrderKey child_k, @@ -103,17 +70,14 @@ public: const orderman::Book& get_book(size_t leg_index) const override; const LegPropertyData& get_leg_data(size_t leg_index) const override; // this is exposed for testing reasons only - State test_only_func_state (); + SpreaderState test_only_func_state (); SpreaderLegData& test_only_func_leg_data (size_t index); private: - void _construct_bookkeeping_data_and_quoters (); - void _subscribe_to_marketdata (); - void _init_quoters (); void _transform_to_START(); void _transform_to_WAITING_FOR_FIRST_CONNECTION(); void _transform_to_WORKING(); void _transform_to_WAITING_FOR_CANCEL_ALL(); - void _transform_to_END(); + void _transform_to_END(std::string* m = nullptr); // this cancels the quoters and hedger orders (through them); // can cancel the quotes or the hedges or both void _cancel_orders(bool cancel_quotes, bool cancel_hedges); @@ -122,28 +86,43 @@ private: bool _all_quoter_orders_in_terminal_state(); // same as _all_quoter_orders_in_terminal_state, for hedgers bool _all_hedger_orders_in_terminal_state(); + // sends all the quoters immedatly to the their terminal state + // abandoning everything they were doing void _terminate_quoters (); + // same as the above for hedgers void _terminate_hedgers(); bool _quoters_can_accept_modification(); + // this sends a hedge (creates a hedger and inits it) + // on leg 'leg_to_hedge_index' in response to a fill + // in leg 'filled_leg_index' with price 'filled_price' + // quantity 'filled_quantity' void _send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_to_hedge_index); + // purely a computating function that computes the + // hedge price and quantity (last 2 args) for leg + // 'hedged_leg_index' for a fill on leg 'filled_leg_index' + // with price 'filled_price' and quantity 'filled_quantity' void _compute_hedge_price_quantity(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, - size_t hedged_index, + size_t hedged_leg_index, Price& hedge_price, Quantity& hedge_quantity); - void report_state(); - void report_state (api::orderman::OrderStatus order_status); - void report_state (api::orderman::OrderStatus order_status, std::string& message); - bool can_resolve_securties(); - void update_spreader_order (Price price, Quantity quantity); - SpreaderBookkeepingData& bookkeeping_data (); + void _report_state (api::orderman::OrderStatus order_status, std::string* message = nullptr); + void _switch_state (ISpreaderStateWorker* new_state); + bts::orderman::SpreaderOrderBase::ChildOrder _get_new_order (const LegPropertyData& leg_property_data, bool is_quote_order); private: - struct PImpl; - std::unique_ptr me; + std::string _msg; + const bool _active; + const api::orderman::CreateOrderRequest _create_order_request; + SpreaderBookkeepingData _bookkeeping_data; friend class SpreaderStartStateWorker; friend class SpreaderWaitingForFirstConnStateWorker; friend class SpreaderWorkingStateWorker; friend class SpreaderWaitingForCancelAllStateWorker; friend class SpreaderEndStateWorker; + ISpreaderStateWorker* _state_worker; + SpreaderStartStateWorker _start_state_worker; + SpreaderWaitingForFirstConnStateWorker _waiting_for_first_conn_state_worker; + SpreaderWorkingStateWorker _working_state_worker; + SpreaderWaitingForCancelAllStateWorker _waiting_for_cancel_all_state_worker; + SpreaderEndStateWorker _end_state_worker; }; - -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp index 8a61812a0..c64b89f56 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.cpp @@ -134,4 +134,6 @@ void SpreaderOrderBase::report_state_change(SpreaderOrderState const&sos) } } +securities::ISecurityDB& SpreaderOrderBase::_db() {return me->sec_db;} + }} diff --git a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h index 311992c68..5cfd51a3f 100644 --- a/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h +++ b/src/server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h @@ -106,8 +106,6 @@ public: _key = rhs._key; return *this; } - - private: NativeOrder* _order; event_grid::Signal _create; @@ -160,7 +158,8 @@ public: ChildFactory get_child_factory(const api::Security&,api::Side, api::orderman::ChildOrderKind); - +protected: + securities::ISecurityDB& _db(); private: struct PImpl; std::unique_ptr me; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp index 17f3c04b7..7d6ca0207 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp @@ -4,17 +4,16 @@ namespace bts { namespace orderman { -SpreaderEndStateWorker::SpreaderEndStateWorker () {} +SpreaderEndStateWorker::SpreaderEndStateWorker () : _state_text ("END") {} +SpreaderState SpreaderEndStateWorker::state() const {return SpreaderState::END;} +const std::string& SpreaderEndStateWorker::state_text () const {return _state_text;} void SpreaderEndStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderEndStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderEndStateWorker::init () { - // all error-free order status updates in this state (and the next) - // are OS_PENDING_NEW. order goes to OS_NEW once it is WORKING - bts_assert_msg(false, "Illegal Spreader operation {END,on_connect}"); + bts_assert_msg (false, "SpreaderEndStateWorker::init is an illegal operation"); } void SpreaderEndStateWorker::on_connect() { @@ -42,12 +41,10 @@ void SpreaderEndStateWorker::on_hedger_order_error(OrderKey, api::orderman::Orde {} void SpreaderEndStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) {} -void SpreaderEndStateWorker::on_external_error(std::string const& err_msg) +void SpreaderEndStateWorker::on_external_error(std::string const&) { - LOG(OrderMan, Warn, "SpreaderEndStateWorker.on_external_error err_msg:{}", err_msg); } void SpreaderEndStateWorker::on_check_termination () { } - }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h index 9b167956d..1315b799f 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderEndStateWorker.h @@ -10,10 +10,12 @@ class SpreaderEndStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderEndStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp index 4d6d65953..03e06e0d8 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp @@ -4,68 +4,62 @@ namespace bts { namespace orderman { -SpreaderStartStateWorker::SpreaderStartStateWorker () {} +SpreaderStartStateWorker::SpreaderStartStateWorker (): _state_text ("START") {} +SpreaderState SpreaderStartStateWorker::state() const {return SpreaderState::START;} +const std::string& SpreaderStartStateWorker::state_text () const {return _state_text;} void SpreaderStartStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderStartStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderStartStateWorker::init () { - // all error-free order status updates in this state (and the next) - // are OS_PENDING_NEW. order goes to OS_NEW once it is WORKING - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_NEW); _spreader->_transform_to_WAITING_FOR_FIRST_CONNECTION (); } void SpreaderStartStateWorker::on_connect() { - bts_assert_msg(false, "Illegal Spreader operation {START,on_connect}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_connect is an illegal operation"); } void SpreaderStartStateWorker::on_disconnect() { - bts_assert_msg(false, "Illegal Spreader operation {START,on_disconnect}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_disconnect is an illegal operation"); } void SpreaderStartStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update) { - _spreader->update_spreader_order (Price(order_update.price()), Quantity (order_update.quantity())); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_NEW); + _spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity())); } void SpreaderStartStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); _spreader->_transform_to_END(); } void SpreaderStartStateWorker::on_book(TickToTradeCorID, Book const&) { - bts_assert_msg (false, "Illegal Spreader operation {state,event} START,on_book"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_book is an illegal operation"); } void SpreaderStartStateWorker::on_time(const TimeStamp&) { } void SpreaderStartStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_quoter_order_error}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_quoter_order_error is an illegal operation"); } void SpreaderStartStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_quoter_order_fill}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_quoter_order_fill is an illegal operation"); } void SpreaderStartStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_quoter_order_status_update}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_quoter_order_status_update is an illegal operation"); } void SpreaderStartStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_hedger_order_error}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_hedger_order_error is an illegal operation"); } void SpreaderStartStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {START,on_hedger_order_upate}"); + bts_assert_msg (false, "SpreaderStartStateWorker::on_hedger_order_update is an illegal operation"); } -void SpreaderStartStateWorker::on_external_error(std::string const& err_msg) +void SpreaderStartStateWorker::on_external_error(std::string const&) { - std::string msg = err_msg; - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg); _spreader->_transform_to_END (); } void SpreaderStartStateWorker::on_check_termination () diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h index 816fc7118..d58b674cc 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderStartStateWorker.h @@ -5,15 +5,19 @@ namespace bts { namespace orderman { class SpreaderOrder; - +//this is the start state which is where the spreader +//gets right after the constructor. it leaves this state +// on an init calls class SpreaderStartStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderStartStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h new file mode 100644 index 000000000..650a3f8d0 --- /dev/null +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderState.h @@ -0,0 +1,18 @@ +#pragma once + +namespace bts{ +namespace orderman{ +enum class SpreaderState +{ + // pre init state + START, + // once init happens, it waits for the first connection + WAITING_FOR_FIRST_CONNECT, + // after the first connection, the general waiting state + WORKING, + // waiting for all quoters and hedgers to be done + WAITING_FOR_CANCEL_ALL, + // end state + END +}; +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp index 0633b4930..fbb902cc1 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp @@ -4,34 +4,32 @@ namespace bts { namespace orderman { -SpreaderWaitingForCancelAllStateWorker::SpreaderWaitingForCancelAllStateWorker () {} +SpreaderWaitingForCancelAllStateWorker::SpreaderWaitingForCancelAllStateWorker (): _state_text ("WAITING_FOR_CANCEL_ALL") {} +SpreaderState SpreaderWaitingForCancelAllStateWorker::state() const {return SpreaderState::WAITING_FOR_CANCEL_ALL;} +const std::string& SpreaderWaitingForCancelAllStateWorker::state_text () const {return _state_text;} void SpreaderWaitingForCancelAllStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderWaitingForCancelAllStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderWaitingForCancelAllStateWorker::init () { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_CANCEL_ALL,init}"); + bts_assert_msg (false, "SpreaderWaitingForCancelAllStateWorker::init is an illegal operation"); } void SpreaderWaitingForCancelAllStateWorker::on_connect() { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_CANCEL_ALL,on_connect}"); + bts_assert_msg (false, "SpreaderWaitingForCancelAllStateWorker::on_connect is an illegal operation"); } void SpreaderWaitingForCancelAllStateWorker::on_disconnect() { _spreader->_terminate_quoters(); _spreader->_terminate_hedgers (); - _spreader->report_state (api::orderman::OrderStatus::OS_STOPPED); _spreader->_transform_to_END (); } void SpreaderWaitingForCancelAllStateWorker::on_update(const api::orderman::UpdateSpreaderOrder&) { - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK); } void SpreaderWaitingForCancelAllStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { - // nothing already waiting for cancel } void SpreaderWaitingForCancelAllStateWorker::on_book(TickToTradeCorID, Book const&) { @@ -40,9 +38,10 @@ void SpreaderWaitingForCancelAllStateWorker::on_time(const TimeStamp&) { // TODO, if enough time has elapsed then tranform to end } -void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*) +void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { - // on_error results in cancelling, however this is already waiting for cancel here + leg_data.order_update_message().update (status, filled_quantity, average_price, err_msg); + leg_data.quoter().update_order_status (leg_data.order_update_message()); } void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) @@ -54,13 +53,23 @@ void SpreaderWaitingForCancelAllStateWorker::on_quoter_order_status_update(bts:: { leg_data.order_update_message().update (status); } -void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) +void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { - // on_error results in cancelling, however this is already waiting for cancel here + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, err_msg); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } } -void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) +void SpreaderWaitingForCancelAllStateWorker::on_hedger_order_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) { - // TODO, update hedger + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, nullptr); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } } void SpreaderWaitingForCancelAllStateWorker::on_external_error(std::string const&) { @@ -68,9 +77,6 @@ void SpreaderWaitingForCancelAllStateWorker::on_external_error(std::string const void SpreaderWaitingForCancelAllStateWorker::on_check_termination() { if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) - { - _spreader->report_state (); // TODO, figure out if it was filled or cxl'ed _spreader->_transform_to_END (); - } } }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h index cb900fe6f..74f370643 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.h @@ -10,10 +10,12 @@ class SpreaderWaitingForCancelAllStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderWaitingForCancelAllStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp index 58d76750a..a30405b94 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.cpp @@ -1,84 +1,164 @@ #include "SpreaderWaitingForFirstConnStateWorker.h" #include "server/sparkd/orderman/spreader_orders/SpreaderOrder.h" +#include "server/sparkd/spreader/SpreaderUtils.h" +#include "server/sparkd/orderman/spreader_orders/SpreaderOrderBase.h" namespace bts { namespace orderman { -SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker () {} +SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker (): _state_text ("WAITING_FOR_FIRST_CONNECT") {} +SpreaderState SpreaderWaitingForFirstConnStateWorker::state() const {return SpreaderState::WAITING_FOR_FIRST_CONNECT;} +const std::string& SpreaderWaitingForFirstConnStateWorker::state_text () const {return _state_text;} void SpreaderWaitingForFirstConnStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderWaitingForFirstConnStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderWaitingForFirstConnStateWorker::init () { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,init}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::init is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_connect() { - if (_spreader->can_resolve_securties ()) + // this is where all the initialization happens. + // if the securities are resolved successfully + // it goes to the working state + if (_can_resolve_securities ()) { - _spreader->_construct_bookkeeping_data_and_quoters (); - _spreader->_init_quoters(); - _spreader->_subscribe_to_marketdata (); - _spreader->report_state (api::orderman::OrderStatus::OS_NEW); + // this creates the bookkeeping data (which contains the quoters) + _construct_bookkeeping_data_and_quoters (); + _init_quoters (); + _subscribe_to_marketdata (); _spreader->_transform_to_WORKING (); } else { // if securities can not be resolved, the order is terminated + LOG(OrderMan, Diag, "SpreaderWaitingForFirstConnStateWorker.on_connect key: {} , could not resolve securities", _spreader->key().value()); std::string msg = "Could not resolve securities"; - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg); - _spreader->_transform_to_END (); + _spreader->_transform_to_END (&msg); } } void SpreaderWaitingForFirstConnStateWorker::on_disconnect() { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_disconnect}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_disconnect is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update) { - _spreader->update_spreader_order (Price(order_update.price()), Quantity (order_update.quantity())); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_NEW); + _spreader->_bookkeeping_data.update_order (Price(order_update.price()), Quantity (order_update.quantity())); } void SpreaderWaitingForFirstConnStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); - _spreader->_transform_to_END(); + std::string msg = "Order cancelled"; + _spreader->_transform_to_END(&msg); } void SpreaderWaitingForFirstConnStateWorker::on_book(TickToTradeCorID, Book const&) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_book}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_book is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_time(const TimeStamp&) { } void SpreaderWaitingForFirstConnStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_quoter_order_error}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_quoter_order_error is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_quoter_order_fill}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_quoter_order_fill is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData&, api::orderman::OrderStatus) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_quoter_order_status_update}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_quoter_order_status_update is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_hedger_order_error}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_hedger_order_error is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) { - bts_assert_msg (false, "Illegal Spreader operation {WAITING_FOR_FIRST_CONNECT,on_hedger_order_upate}"); + bts_assert_msg (false, "SpreaderWaitingForFirstConnStateWorker::on_hedger_order_update is an illegal operation"); } void SpreaderWaitingForFirstConnStateWorker::on_external_error(std::string const& err_msg) { - std::string msg = err_msg; - _spreader->report_state (api::orderman::OrderStatus::OS_REJECTED_BY_SPARK, msg); - _spreader->_transform_to_END (); + std::string msg = "Error message: " + err_msg; + _spreader->_transform_to_END (&msg); } void SpreaderWaitingForFirstConnStateWorker::on_check_termination() {} +void SpreaderWaitingForFirstConnStateWorker::_init_quoters () +{ + for (size_t index = 0; index < _spreader->_bookkeeping_data.count(); index++) + { + SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(index); + if (leg_data.leg_property_data.is_active_quoting()) + leg_data.quoter().init(); + } +} +bool SpreaderWaitingForFirstConnStateWorker::_can_resolve_securities () +{ + // when the synthetic sec's are truly moved to the server, + // the sec (below) is also resolved (vs getting it directly + // from the CreateSpreaderOrder) + const bts::api::Security& sec = _spreader->_create_order_request.spreader().security(); + for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) + { + const bts::api::ContractLeg& leg = *it; + bts::SecurityKey leg_key = bts::SecurityKey (leg.security().id()); + if (leg.security().has_future() || leg.security().has_spread()) + { + api::Security const* db_sec = _spreader->_db().resolve (leg_key); + if (db_sec == nullptr) + { + LOG(OrderMan, Error, "SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker key: {} , could not resolve sec key: {}", _spreader->key().value(), leg_key.value()); + return false; + } + } + else + { + LOG(OrderMan, Error, "SpreaderWaitingForFirstConnStateWorker::SpreaderWaitingForFirstConnStateWorker key: {} , only futures and future spread legs supported sec key: {}", _spreader->key().value(), leg_key.value()); + return false; + } + } + return true; +} +void SpreaderWaitingForFirstConnStateWorker::_subscribe_to_marketdata() +{ + for (size_t index = 0; index < _spreader->_bookkeeping_data.count(); index++) + { + SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(index); + bts::SecurityKey leg_key = bts::SecurityKey (leg_data.leg_property_data.security_key()); + api::Security const* db_sec = _spreader->_db().resolve (leg_key); + _spreader->subscribe_to_md (*db_sec); + } +} +void SpreaderWaitingForFirstConnStateWorker::_construct_bookkeeping_data_and_quoters() +{ + std::vector leg_data_vector; + //creating the basic data + ISpreaderManager& me_ref = *_spreader; + const bts::api::orderman::CreateSpreaderOrder& cor = _spreader->_create_order_request.spreader(); + spark::ExecutionStrategy execution_strategy = cor.execution_strategy(); + const bts::api::Security& sec = cor.security(); + size_t leg_idx = 0; + for (auto it = sec.synthetic().legs().begin(); it != sec.synthetic().legs().end(); ++it) + { + // i. immutable property data for this leg + const bts::api::ContractLeg& leg = *it; + auto leg_exec_strategy_it = execution_strategy.leg_params_map().find(leg.security().id()); + bts_assert(leg_exec_strategy_it != execution_strategy.leg_params_map().end()); + api::Side leg_order_side = SpreaderUtils::get_leg_side(cor.side(), leg); + LegPropertyData leg_property_data(leg_idx, leg, leg_exec_strategy_it->second, leg_order_side); + // ii. setting up the order for this leg + bts::orderman::SpreaderOrderBase::ChildOrder child_order = _spreader->_get_new_order (leg_property_data, api::orderman::ChildOrderKind::COK_SPREADER_QUOTING); + LOG(OrderMan, Diag, "Initiazing quoting order {} owned by spreader order {}", child_order.order_key().value(), _spreader->key().value()); + // iii. setting up the quoter (which needs the quoter and property from i and ii) + SingleLegQuoter leg_quoter(me_ref, leg_property_data, sec.synthetic().legs().size(), Price(cor.price()), Quantity(cor.quantity()), child_order); + // iv. finally setting up the full leg_data (which needs the quoter and property from i, ii and iii) + SpreaderLegData leg_data(leg_property_data, leg_quoter, child_order.order_key()); + leg_data_vector.push_back(leg_data); + leg_idx++; + } + bts_assert(leg_data_vector.size() > 0); + _spreader->_bookkeeping_data = SpreaderBookkeepingData(leg_data_vector, Price(cor.price()), Quantity(cor.quantity())); +} }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h index b41c6a50f..291148942 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWaitingForFirstConnStateWorker.h @@ -10,10 +10,12 @@ class SpreaderWaitingForFirstConnStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderWaitingForFirstConnStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; @@ -28,6 +30,18 @@ public: void on_hedger_order_update(OrderKey child_k, api::orderman::OrderStatus, Quantity filled_quantity, Price average_price) override; void on_external_error(std::string const&) override; void on_check_termination () override; +private: + // iterates through the spreader leg and verifies + // that every security can be resolved + bool _can_resolve_securities (); + // creates the bookkeeping data and constructs + // the quoters + void _construct_bookkeeping_data_and_quoters (); + // calls init on all the quoters + void _init_quoters (); + // iterates through the spreader legs and subs + // to the market data + void _subscribe_to_marketdata (); }; }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 950070499..716ed4cd1 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -4,60 +4,51 @@ namespace bts { namespace orderman { -SpreaderWorkingStateWorker::SpreaderWorkingStateWorker () {} +SpreaderWorkingStateWorker::SpreaderWorkingStateWorker (): _state_text ("WORKING") {} +SpreaderState SpreaderWorkingStateWorker::state() const {return SpreaderState::WORKING;} +const std::string& SpreaderWorkingStateWorker::state_text () const {return _state_text;} void SpreaderWorkingStateWorker::build_once (SpreaderOrder* spreader) { _spreader = spreader; } -//SpreaderOrder::State SpreaderWorkingStateWorker::state() const {return SpreaderOrder::State::START;} void SpreaderWorkingStateWorker::init () { - bts_assert_msg(false, "Illegal Spreader operation {WORKING,init}"); + bts_assert_msg (false, "SpreaderWorkingStateWorker::init is an illegal operation"); } void SpreaderWorkingStateWorker::on_connect() { - bts_assert_msg(false, "Illegal Spreader operation {WORKING,on_connect}"); + bts_assert_msg (false, "SpreaderWorkingStateWorker::on_connect is an illegal operation"); } void SpreaderWorkingStateWorker::on_disconnect() { _spreader->_terminate_quoters (); _spreader->_terminate_hedgers(); - _spreader->report_state (api::orderman::OrderStatus::OS_CANCELED); - _spreader->_transform_to_END (); + _spreader->_msg = "disconnected"; + _spreader->_transform_to_END (&(_spreader->_msg)); } -void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& order_update) +void SpreaderWorkingStateWorker::on_update(const api::orderman::UpdateSpreaderOrder& u) { if (_spreader->_quoters_can_accept_modification()) { - Price new_price (order_update.price()); Quantity new_quantity (order_update.quantity()); - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); - // updating internal state - _spreader->update_spreader_order (new_price, new_quantity); - // updating all active quoters - for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++) + Price price (u.price()); Quantity quantity(u.quantity()); + _spreader->_bookkeeping_data.update_order (price, quantity); + // updating all active quoters, nothing to do with the hedgers + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data.count(); q_idx++) { - SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx); + SpreaderLegData& leg_data = _spreader->_bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data.is_active_quoting()) - leg_data.quoter().update_order_price_quantity (new_price, new_quantity); + leg_data.quoter().update_order_price_quantity (price, quantity); } - // reporting state - _spreader->report_state (api::orderman::OrderStatus::OS_NEW); - } - else - { - // quoters were not ready, this change is rejected - _spreader->report_state (); } } void SpreaderWorkingStateWorker::on_cancel(const api::orderman::CancelSpreaderOrder&) { _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book) { - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); + SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data; // this is a key->index lookup SpreaderLegData& md_leg = bookkeeping_data.get_leg_data(book.security_key()); // updating md state (this is the only place where its done) @@ -67,26 +58,24 @@ void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, const Book& book) { SpreaderLegData& d = bookkeeping_data.get_leg_data(q_idx); if (d.leg_property_data.is_active_quoting()) - d.quoter().update_md(cid, md_leg.leg_property_data.leg_index); + d.quoter().on_book(cid, md_leg.leg_property_data.leg_index, book); } // send md to hedgers hedging this security only for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++) - { - SpreaderHedgerData& h = md_leg.get_hedger(h_idx); - h.hedger().on_book(cid, book); - } + md_leg.get_hedger(h_idx).hedger().on_book(cid, book); } -void SpreaderWorkingStateWorker::on_time(const TimeStamp&) +void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts) { - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); + SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data; for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++) { - SpreaderLegData& d = bookkeeping_data.get_leg_data(q_idx); - if (d.leg_property_data.is_active_quoting()) + SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx); + if (leg_data.leg_property_data.is_active_quoting()) { - // same f'ing timestamp - // d.quoter().on_time (ts); - } + leg_data.quoter().on_time(ts); + for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) + leg_data.get_hedger(h_idx).hedger().on_time (ts); + } } } void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) @@ -95,7 +84,6 @@ void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLe // this is because the error message could also have status changes leg_data.quoter().update_order_status (leg_data.order_update_message()); _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) @@ -108,17 +96,16 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg // 5. init the hedger leg_data.order_update_message().update (status, filled_quantity, average_price, nullptr); leg_data.quoter().update_order_status (leg_data.order_update_message()); - SpreaderBookkeepingData& bookkeeping_data = _spreader->bookkeeping_data (); - for (size_t q_idx = 0; q_idx < bookkeeping_data.count(); q_idx++) + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data.count(); q_idx++) { - bts::orderman::SpreaderLegData other_leg_data = bookkeeping_data.get_leg_data (q_idx); + bts::orderman::SpreaderLegData other_leg_data = _spreader->_bookkeeping_data.get_leg_data (q_idx); if (q_idx != leg_data.leg_property_data.leg_index) { // if it is an actively quoting leg, inform the quoter about it // so it can decrease the proportional size if (other_leg_data.leg_property_data.is_active_quoting()) other_leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data.leg_index, filled_quantity); - // a hedge is sent regsardless + // a hedge is sent regardless _spreader->_send_hedge (leg_data.leg_property_data.leg_index, average_price, filled_quantity, q_idx); } } @@ -128,31 +115,34 @@ void SpreaderWorkingStateWorker::on_quoter_order_status_update(bts::orderman::Sp leg_data.order_update_message().update (status); leg_data.quoter().update_order_status (leg_data.order_update_message()); } -void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey, api::orderman::OrderStatus, Quantity, Price, std::string const*) +void SpreaderWorkingStateWorker::on_hedger_order_error(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price, std::string const* err_msg) { - // TODO:update hedger order state - //leg_data.order_update_message().update(status, filled_quantity, average_price, err_msg); + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, err_msg); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } -void SpreaderWorkingStateWorker::on_hedger_order_update(OrderKey, api::orderman::OrderStatus, Quantity, Price) +void SpreaderWorkingStateWorker::on_hedger_order_update(OrderKey order_key, api::orderman::OrderStatus status, Quantity filled_quantity, Price average_price) { - // TODO - bts_assert_msg (false, "Illegal Spreader operation {WORKING,on_hedger_order_upate}"); + SpreaderHedgerData* hedger_data = _spreader->_bookkeeping_data.find_hedger_from_orderkey(order_key); + if (hedger_data != nullptr) + { + hedger_data->order_update_message().update(status, filled_quantity, average_price, nullptr); + hedger_data->hedger().on_order_update(hedger_data->order_update_message()); + } } void SpreaderWorkingStateWorker::on_external_error(std::string const&) { _spreader->_cancel_orders (true, true); - _spreader->report_state (api::orderman::OrderStatus::OS_PENDING_CANCEL); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } void SpreaderWorkingStateWorker::on_check_termination() { if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) - { - _spreader->report_state (); // TODO, figure out if it was filled or cxl'ed _spreader->_transform_to_END (); - } } }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h index 0e989f15b..c514eef3d 100644 --- a/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h +++ b/src/server/sparkd/orderman/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h @@ -10,10 +10,12 @@ class SpreaderWorkingStateWorker : public ISpreaderStateWorker { private: SpreaderOrder* _spreader; + const std::string _state_text; public: SpreaderWorkingStateWorker (); void build_once (SpreaderOrder* spreader_order) override; - //SpreaderOrder::State state() const override; + SpreaderState state() const override; + const std::string& state_text () const override; void init () override; void on_connect() override; void on_disconnect() override; diff --git a/src/server/sparkd/orderman/tests/spreader_order_tests.cpp b/src/server/sparkd/orderman/tests/spreader_order_tests.cpp index a28860a5e..c93c2f5fb 100644 --- a/src/server/sparkd/orderman/tests/spreader_order_tests.cpp +++ b/src/server/sparkd/orderman/tests/spreader_order_tests.cpp @@ -233,13 +233,13 @@ void disabled_temp() do_nothing, do_nothing, do_nothing); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::START); + bts_assert (order.test_only_func_state() == SpreaderState::START); /*********************Initing the order********************/ order.init (); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::WAITING_FOR_FIRST_CONNECT); + bts_assert (order.test_only_func_state() == SpreaderState::WAITING_FOR_FIRST_CONNECT); /*********************First on_connect*********************/ order.on_connect (); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::WORKING); + bts_assert (order.test_only_func_state() == SpreaderState::WORKING); bts::orderman::SpreaderLegData& leg_data = order.test_only_func_leg_data (1); bts_assert (leg_data.quoter().test_only_func_state() == QuoterState::WAITING_FOR_SIZE); const QuoteLegPriceQuantityState& qp_state = leg_data.quoter().test_only_func_price_quantity_state (); @@ -301,12 +301,12 @@ void disabled_temp() // fill it all // cancel it // order.on_cancel (api::orderman::CancelSpreaderOrder()); - // bts_assert (order.test_only_func_state() == SpreaderOrder::State::WAITING_FOR_CANCEL_ALL); + // bts_assert (order.test_only_func_state() == SpreaderState::WAITING_FOR_CANCEL_ALL); // bts_assert (leg_data.quoter().test_only_func_state() == SingleLegQuoter::QuoterState::WAITING_FOR_CANCEL_ACK); // send cxl ack order.on_child_update (bts::orderman::OrderKey (0), api::orderman::OrderStatus::OS_CANCELED, Quantity(23), Price(2500), nullptr); - bts_assert (order.test_only_func_state() == SpreaderOrder::State::END); + bts_assert (order.test_only_func_state() == SpreaderState::END); bts_assert (leg_data.quoter().test_only_func_state() == QuoterState::END); } } diff --git a/src/server/sparkd/risk_limits/RiskLimitManager.cpp b/src/server/sparkd/risk_limits/RiskLimitManager.cpp index 4ab6e757a..40d668127 100644 --- a/src/server/sparkd/risk_limits/RiskLimitManager.cpp +++ b/src/server/sparkd/risk_limits/RiskLimitManager.cpp @@ -5,8 +5,8 @@ #include "IRiskLimitObserver.h" #include "lib/config/config.h" -#include "lib/config/protos/Account.pb.h" -#include "lib/config/protos/User.pb.h" +#include "lib/api/services/AccountService.client.pb.h" +#include "lib/api/services/UserService.client.pb.h" #include "lib/domain_model/Security.pb.h" #include "lib/utils/bts_assert.h" @@ -18,71 +18,66 @@ using namespace bts::orderman; -namespace bts { -namespace risklimits { - -using OperatorMap = boost::container::flat_map; - +namespace bts +{ +namespace risklimits +{ using KeyType = std::tuple; using SharedLimiterMap = boost::container::flat_map>; -using StateKeyType = std::tuple; -using PBLimitsMap = const google::protobuf::Map; +using OperatorMap = boost::container::flat_map; +using PBLimitsMap = google::protobuf::Map; + struct RiskLimitManager::PImpl { RiskLimitManager& this_ptr; - OperatorMap operator_map; SharedLimiterMap limiter_map; std::vector observers; - boost::container::flat_map aggregate_state; - + PImpl(RiskLimitManager& rm) : - this_ptr(rm), - operator_map(), limiter_map(), observers(), aggregate_state() + this_ptr(rm), limiter_map(), observers() { } - - void init() - { - auto users = config::get(); - for(int i = 0; i < users.user_size(); i++) - { - auto user = users.user(i); - for(int j = 0; j < user.operators_size(); j++) - operator_map[user.operators(j).operator_id().id()] = user.operators(j); - } - - auto accts = config::get(); - for(int i = 0; i < accts.accounts_with_limits_size(); i++) - { - const auto& acct = accts.accounts_with_limits(i).account(); - const auto& future_limit = accts.accounts_with_limits(i).future_limits(); - update_limits(future_limit, acct, api::Security::kFuture); - const auto& spread_limit = accts.accounts_with_limits(i).spread_limits(); - update_limits(spread_limit, acct, api::Security::kSpread); - } - } - - void update_limits(PBLimitsMap & map, const bts::config::Account & acct, api::Security::ContractCase contract_type) + + void update_limits(const OperatorMap& operator_map, const PBLimitsMap& map, + const api::account::Account & acct, api::Security::ContractCase contract_type) { for(const auto& j : map) { for(int k = 0; k < acct.allowed_operators_size(); k++) { - auto allowed = operator_map.find(acct.allowed_operators(k).id()); + auto allowed = operator_map.find(acct.allowed_operators(k).tag50()); if(allowed != operator_map.end()) { - OperatorID opid = to(allowed->second.operator_id().id()); + OperatorID opid = to(allowed->second->operator_id().tag50()); SharedRiskLimiter& lim = find_limiter(to_accountname(acct), opid, to_symbolkey(j.first, contract_type)); lim.on_account_update(acct); - lim.on_operator_update(allowed->second); + lim.on_operator_update(*allowed->second); lim.on_risk_limit_update(j.second); } } } + } + + void initialize(const std::vector& accounts, const std::vector& users) + { + limiter_map.clear(); + OperatorMap operators; + for(const auto& u : users) + { + for(int i = 0; i < u.operators_size(); i++) + operators[u.operators(i).operator_id().tag50()] = &u.operators(i); + } + for(const auto& acct : accounts) + { + const auto& future_limit = acct.future_limits(); + update_limits(operators, future_limit, acct, api::Security::kFuture); + const auto& spread_limit = acct.spread_limits(); + update_limits(operators, spread_limit, acct, api::Security::kSpread); + } } - + SymbolKey to_symbolkey(const api::Security& security) { return SymbolKey(security.symbol(), security.Contract_case()); @@ -91,9 +86,9 @@ struct RiskLimitManager::PImpl { return SymbolKey(symbol, type); } - AccountName to_accountname(const config::Account& key) + AccountName to_accountname(const api::account::Account& key) { - return to(key.account_id()); + return to(key.tag1()); } SharedRiskLimiter& find_limiter(const AccountName& acctname, const OperatorID& opid, const SymbolKey& symkey) @@ -101,17 +96,15 @@ struct RiskLimitManager::PImpl KeyType key(acctname, opid, symkey); auto& lim = limiter_map[key]; if(!lim) - lim = std::make_shared(this_ptr, std::get<0>(key), std::get<1>(key), std::get<2>(key)); + lim = std::make_shared(this_ptr, acctname, opid, symkey); return *lim; } }; - RiskLimitManager::RiskLimitManager(IRiskLimitObserver* observer) : me(new PImpl(*this)) { if(observer) me->observers.push_back(observer); - me->init(); } RiskLimitManager::~RiskLimitManager() {} @@ -124,12 +117,8 @@ RiskLimiter& RiskLimitManager::find_limiter(const AccountName& acctname, const O void RiskLimitManager::on_limit_state_change(RiskLimitState state) { - StateKeyType sk = std::make_tuple(state.account_name, state.operator_id); - me->aggregate_state[sk] = state; - std::vector res; - for(const auto& kvp : me->aggregate_state) - res.push_back(kvp.second); + res.push_back(state); for(const auto& i : me->observers) i->on_limit_state(res); } @@ -146,5 +135,12 @@ void RiskLimitManager::all_shared_limiters(std::vector& accounts, + const std::vector& users) +{ + me->initialize(accounts, users); +} + + } } diff --git a/src/server/sparkd/risk_limits/RiskLimitManager.h b/src/server/sparkd/risk_limits/RiskLimitManager.h index 3fd933d41..51693d747 100644 --- a/src/server/sparkd/risk_limits/RiskLimitManager.h +++ b/src/server/sparkd/risk_limits/RiskLimitManager.h @@ -10,7 +10,19 @@ namespace bts { -namespace api { class Security; } +namespace api +{ + class Security; + namespace user + { + class User; + } + namespace account + { + class Account; + class AccountBalance; + } +} namespace risklimits { class IRiskLimitObserver; @@ -25,10 +37,12 @@ public: RiskLimiter& find_limiter(const orderman::AccountName&, const orderman::OperatorID&, const api::Security&, orderman::OrderKey); + + void initialize(const std::vector&, const std::vector&); protected: friend class SharedRiskLimiter; - void on_limit_state_change(RiskLimitState state); + void on_limit_state_change(RiskLimitState state); protected: friend class RiskLimitsTests; @@ -39,5 +53,4 @@ private: struct PImpl; std::unique_ptr me; }; -} -} +}} diff --git a/src/server/sparkd/risk_limits/RiskLimiter.cpp b/src/server/sparkd/risk_limits/RiskLimiter.cpp index 1088115f9..0b332cb6e 100644 --- a/src/server/sparkd/risk_limits/RiskLimiter.cpp +++ b/src/server/sparkd/risk_limits/RiskLimiter.cpp @@ -2,10 +2,9 @@ #include "SharedRiskLimiter.h" - #include "lib/config/config.h" -#include "lib/config/protos/Account.pb.h" -#include "lib/config/protos/User.pb.h" +#include "lib/api/services/AccountService.pb.h" +#include "lib/api/services/UserService.pb.h" #include "lib/utils/bts_assert.h" #include "lib/logging/logging.h" @@ -90,7 +89,6 @@ struct RiskLimiter::PImpl } }; - RiskLimiter::RiskLimiter(SharedRiskLimiter& sh, orderman::OrderKey key) : me(new PImpl(sh, key)) { @@ -112,7 +110,6 @@ RiskLimiter::RiskLimitResult RiskLimiter::check(Quantity qty, api::Side side) co return res; } - void RiskLimiter::on_order_state(api::Side side, Quantity quantity, Quantity filled_quantity) { auto remaining = Quantity(quantity.value() - filled_quantity.value()); diff --git a/src/server/sparkd/risk_limits/RiskLimiter.h b/src/server/sparkd/risk_limits/RiskLimiter.h index a0db61f29..b1f5dd4a7 100644 --- a/src/server/sparkd/risk_limits/RiskLimiter.h +++ b/src/server/sparkd/risk_limits/RiskLimiter.h @@ -8,7 +8,8 @@ #include #include -namespace bts { +namespace bts +{ namespace risklimits { class SharedRiskLimiter; diff --git a/src/server/sparkd/risk_limits/SharedRiskLimiter.cpp b/src/server/sparkd/risk_limits/SharedRiskLimiter.cpp index 07176b978..b8fe83ddc 100644 --- a/src/server/sparkd/risk_limits/SharedRiskLimiter.cpp +++ b/src/server/sparkd/risk_limits/SharedRiskLimiter.cpp @@ -4,8 +4,8 @@ #include "RiskLimiter.h" #include "lib/config/config.h" -#include "lib/config/protos/Account.pb.h" -#include "lib/config/protos/User.pb.h" +#include "lib/api/services/AccountService.pb.h" +#include "lib/api/services/UserService.pb.h" #include "lib/utils/bts_assert.h" #include "lib/logging/logging.h" @@ -77,32 +77,31 @@ const SymbolKey & SharedRiskLimiter::symbol_key() return me->shared_data.position_info.symbol; } -void SharedRiskLimiter::on_account_update(const config::Account& acct) +void SharedRiskLimiter::on_account_update(const api::account::Account& acct) { - bts_assert(to(acct.account_id()) == me->shared_data.account_info.account); + bts_assert(to(acct.tag1()) == me->shared_data.account_info.account); bool prev = me->shared_data.account_info.can_trade; me->shared_data.account_info.can_trade = acct.can_trade(); if(prev != me->shared_data.account_info.can_trade) me->notify_permission(); - me->shared_data.account_info.cash_position = acct.cash_position(); - //TODO check span + me->shared_data.account_info.cash_position = acct.balance().cash_position(); } -void SharedRiskLimiter::on_operator_update(const config::Operator& oper) +void SharedRiskLimiter::on_operator_update(const api::user::Operator& oper) { - bts_assert(to(oper.operator_id().id()) == me->shared_data.operator_info.opid); + bts_assert(to(oper.operator_id().tag50()) == me->shared_data.operator_info.opid); bool prev = me->shared_data.operator_info.can_trade; me->shared_data.operator_info.can_trade = oper.can_trade(); if(prev != me->shared_data.operator_info.can_trade) me->notify_permission(); } -void SharedRiskLimiter::on_risk_limit_update(const config::RiskLimit& risk) +void SharedRiskLimiter::on_risk_limit_update(const api::account::RiskLimit& risk) { me->shared_data.risk_limit = risk; } -const config::RiskLimit& SharedRiskLimiter::risk_limit() +const api::account::RiskLimit& SharedRiskLimiter::risk_limit() { return me->shared_data.risk_limit; } diff --git a/src/server/sparkd/risk_limits/SharedRiskLimiter.h b/src/server/sparkd/risk_limits/SharedRiskLimiter.h index b44c147bc..b09f5ba1d 100644 --- a/src/server/sparkd/risk_limits/SharedRiskLimiter.h +++ b/src/server/sparkd/risk_limits/SharedRiskLimiter.h @@ -2,21 +2,30 @@ #include "server/sparkd/orderman/utils/orderman_utils.h" #include "SymbolKey.h" -#include "lib/config/protos/Account.pb.h" -#include "lib/domain_model/Security.pb.h" +#include "lib/api/services/AccountService.pb.h" +#include "lib/api/services/UserService.pb.h" #include "lib/utils/bts_no_copy.h" #include #include -namespace bts { -namespace orderman { -class OrderState; -} -namespace config{ -class Account; -class Operator; -class RiskLimit; +namespace bts +{ +namespace orderman { class OrderState; } +namespace api +{ + class Security; + namespace user + { + class User; + class Operator; + } + namespace account + { + class Account; + class AccountBalance; + class RiskLimit; + } } namespace risklimits { @@ -36,7 +45,7 @@ public: struct PositionInfo { SymbolKey symbol; uint32_t long_position; uint32_t short_position; uint32_t long_working; uint32_t short_working; } position_info; - config::RiskLimit risk_limit; + api::account::RiskLimit risk_limit; std::string info_string; }; @@ -52,13 +61,13 @@ public: protected: friend class RiskLimitManager; - void on_account_update(const config::Account&); - void on_operator_update(const config::Operator&); - void on_risk_limit_update(const config::RiskLimit&); + void on_account_update(const api::account::Account&); + void on_operator_update(const api::user::Operator&); + void on_risk_limit_update(const api::account::RiskLimit&); protected: friend class RiskLimitsTests; - const config::RiskLimit& risk_limit(); + const api::account::RiskLimit& risk_limit(); protected: friend class RiskLimiter; diff --git a/src/server/sparkd/risk_limits/SymbolKey.h b/src/server/sparkd/risk_limits/SymbolKey.h index 23ded79a3..b42cae154 100644 --- a/src/server/sparkd/risk_limits/SymbolKey.h +++ b/src/server/sparkd/risk_limits/SymbolKey.h @@ -9,6 +9,6 @@ namespace bts namespace risklimits { -using SymbolKey = std::pair; +using SymbolKey = std::pair; }} diff --git a/src/server/sparkd/risk_limits/tests/RiskLimitsTests.cpp b/src/server/sparkd/risk_limits/tests/RiskLimitsTests.cpp index fe51c99c5..6ef9487c0 100644 --- a/src/server/sparkd/risk_limits/tests/RiskLimitsTests.cpp +++ b/src/server/sparkd/risk_limits/tests/RiskLimitsTests.cpp @@ -5,16 +5,22 @@ #include "../RiskLimiter.h" #include "../RiskLimitState.h" #include "../IRiskLimitObserver.h" +#include "../SymbolKey.h" #include "server/sparkd/orderman/utils/orderman_utils.h" +#include "server/sparkd/user/AccountServiceServer.h" +#include "server/sparkd/user/UserServiceServer.h" + #include "lib/config/config.h" -#include "lib/config/protos/Account.pb.h" -#include "lib/config/protos/User.pb.h" +#include "lib/api/public/ServiceContext.h" +#include "lib/api/services/AccountService.client.pb.h" +#include "lib/api/services/UserService.client.pb.h" #include "lib/domain_model/Security.pb.h" #include "lib/utils/helper_macros.h" #include +#include #include using namespace bts::orderman; @@ -26,7 +32,40 @@ namespace risklimits class RiskLimitsTests { + std::unique_ptr context; + account::AccountServiceServer account_server; + user::UserServiceServer user_server; + api::user::UserService user_service; + api::account::AccountService account_service; public: + RiskLimitsTests() : context(new api::ServiceContext()), + account_server(*context), + user_server(*context), + user_service(context->locate()), + account_service(context->locate()) + { + + } + + void initialize(RiskLimitManager& mgr) + { + auto uresp = user_service.get_users(api::user::GetUsersRequest()); + auto aresp = account_service.get_accounts(api::account::GetAccountsRequest()); + + std::vector users; + std::vector accounts; + const auto& uu = uresp.result()->users(); + users.reserve(uu.size()); + for(const auto& i : uu) + users.push_back(i); + + const auto& aa = aresp.result()->accounts(); + accounts.reserve(aa.size()); + for(const auto& i : aa) + accounts.push_back(i); + mgr.initialize(accounts, users); + } + static void all_shared_limiters(RiskLimitManager& manager, std::vector>& shared_limiters) { @@ -38,7 +77,7 @@ public: { return manager.find_shared_limiter(acct, opid, sec); } - static const config::RiskLimit& risk_limit(SharedRiskLimiter& shared) + static const api::account::RiskLimit& risk_limit(SharedRiskLimiter& shared) { return shared.risk_limit(); } @@ -50,15 +89,15 @@ public: { return lim.shared_data(); } - static void account_update(SharedRiskLimiter& shared, const config::Account& acct) + static void account_update(SharedRiskLimiter& shared, const api::account::Account& acct) { shared.on_account_update(acct); } - static void operator_update(SharedRiskLimiter& shared, const config::Operator& oper) + static void operator_update(SharedRiskLimiter& shared, const api::user::Operator& oper) { shared.on_operator_update(oper); } - static void risk_limit_update(SharedRiskLimiter& shared, const config::RiskLimit& risk) + static void risk_limit_update(SharedRiskLimiter& shared, const api::account::RiskLimit& risk) { shared.on_risk_limit_update(risk); } @@ -107,9 +146,12 @@ RiskLimiter& get_limiter(RiskLimitManager& manager, const std::string& acct, con return lim; } + TEST_CASE ("RiskLimits API", "[risklimits]") { RiskLimitManager _manager; + RiskLimitsTests init; + init.initialize(_manager); SECTION("key_test") { @@ -139,6 +181,7 @@ TEST_CASE ("RiskLimits API", "[risklimits]") std::vector result; Observer obs(&result); RiskLimitManager observed_manager(&obs); + init.initialize(observed_manager); size_t sz = result.size(); REQUIRE(sz > 0); @@ -148,16 +191,18 @@ TEST_CASE ("RiskLimits API", "[risklimits]") bool limits_ok(const std::vector& state) { - bool cancel = true; + bool ok = true; for(auto s : state) - cancel = cancel && s.limits_ok; - return cancel; + ok = ok && s.limits_ok; + return ok; } TEST_CASE ("RiskLimits Limits", "[risklimits]") { using namespace api; RiskLimitManager& _manager = *new RiskLimitManager(); + RiskLimitsTests init; + init.initialize(_manager); SECTION("default_limiter_cant_trade") { @@ -173,15 +218,17 @@ TEST_CASE ("RiskLimits Limits", "[risklimits]") std::vector state; Observer obs(&state); RiskLimitManager observed_manager(&obs); + init.initialize(observed_manager); bool ok = limits_ok(state); REQUIRE(ok); std::vector> limiters; RiskLimitsTests::all_shared_limiters(observed_manager, limiters); + REQUIRE(limiters.size() > 0); for(auto i : limiters) { - const config::RiskLimit& limits = RiskLimitsTests::risk_limit(*i.get()); + const api::account::RiskLimit& limits = RiskLimitsTests::risk_limit(*i.get()); SharedLimiterData& data = RiskLimitsTests::shared_data(*i.get()); api::Security sec = api::Security::default_instance(); setup_security(sec, data.position_info.symbol); @@ -197,8 +244,8 @@ TEST_CASE ("RiskLimits Limits", "[risklimits]") REQUIRE(!res.success); { - config::Account new_account = config::Account::default_instance(); - new_account.set_account_id(to_str(data.account_info.account)); + api::account::Account new_account = api::account::Account::default_instance(); + new_account.set_tag1(to_str(data.account_info.account)); new_account.set_can_trade(false); RiskLimitsTests::account_update(*i.get(), new_account); bool ok = limits_ok(state); @@ -209,9 +256,9 @@ TEST_CASE ("RiskLimits Limits", "[risklimits]") REQUIRE(ok); } { - config::Operator new_oper = config::Operator::default_instance(); + api::user::Operator new_oper = api::user::Operator::default_instance(); auto id = to_str(data.operator_info.opid); - new_oper.mutable_operator_id()->set_id(id); + new_oper.mutable_operator_id()->set_tag50(id); new_oper.set_can_trade(false); RiskLimitsTests::operator_update(*i.get(), new_oper); bool ok = limits_ok(state); @@ -230,18 +277,20 @@ TEST_CASE ("RiskLimits Limits", "[risklimits]") std::vector state; Observer obs(&state); RiskLimitManager observed_manager(&obs); + init.initialize(observed_manager); bool ok = limits_ok(state); REQUIRE(ok); std::vector> limiters; RiskLimitsTests::all_shared_limiters(observed_manager, limiters); + REQUIRE(limiters.size() > 0); int lim_count = 0; for(auto ii : limiters) { lim_count++; SharedRiskLimiter* sh = ii.get(); - const config::RiskLimit& limits = RiskLimitsTests::risk_limit(*sh); + const api::account::RiskLimit& limits = RiskLimitsTests::risk_limit(*sh); SharedLimiterData& data = RiskLimitsTests::shared_data(*sh); api::Security sec = api::Security::default_instance(); setup_security(sec, data.position_info.symbol); diff --git a/src/server/sparkd/spreader/LegPropertyData.h b/src/server/sparkd/spreader/LegPropertyData.h index dd1c5c816..0f0ac53a8 100644 --- a/src/server/sparkd/spreader/LegPropertyData.h +++ b/src/server/sparkd/spreader/LegPropertyData.h @@ -27,7 +27,7 @@ public: { } uint32_t security_key() const { return leg_contract.security().id(); } // TODO: use seckey - //bts::SecurityKey security_key() const {return bts::SecurityKey (leg_contract.security().id());} + //const bts::SecurityKey& security_key() const {return bts::SecurityKey (leg_contract.security().id());} const bts::api::Security& security() const { return leg_contract.security(); } double price_multiplier() const { return leg_params.price_multiplier(); } double size_multiplier() const { return leg_contract.quantity(); } diff --git a/src/server/sparkd/spreader/QuoteLegPriceQuantityState.cpp b/src/server/sparkd/spreader/QuoteLegPriceQuantityState.cpp deleted file mode 100644 index 4f9963a32..000000000 --- a/src/server/sparkd/spreader/QuoteLegPriceQuantityState.cpp +++ /dev/null @@ -1,52 +0,0 @@ -#include "QuoteLegPriceQuantityState.h" - -namespace bts { -namespace orderman { - -QuoteLegPriceQuantityState::QuoteLegPriceQuantityState(Price target_spread_price, Quantity target_leg_quantity) -: - _in_target_spread_price(target_spread_price), - _in_target_leg_quantity(target_leg_quantity), - _aggregated_filled_quantity(0), - _aggregated_hedged_reduction(0), - _out_quantity(0) -{} - -void QuoteLegPriceQuantityState::update_target_spread_price(Price new_target_spread_price) { _in_target_spread_price = new_target_spread_price; } - -void QuoteLegPriceQuantityState::update_target_leg_quantity(Quantity new_target_leg_quantity) { _in_target_leg_quantity = new_target_leg_quantity; } - -void QuoteLegPriceQuantityState::add_filled_quantity(Quantity filled_qty) -{ - _aggregated_filled_quantity = Quantity(_aggregated_filled_quantity.value() + filled_qty.value()); -} - -void QuoteLegPriceQuantityState::update_filled_quantity(Quantity aggregated_filled_quantity) { _aggregated_filled_quantity = Quantity(aggregated_filled_quantity); } - -void QuoteLegPriceQuantityState::add_hedged_reduction(Quantity normalized_hedge_reduction) -{ - _aggregated_hedged_reduction = Quantity(_aggregated_hedged_reduction.value() + normalized_hedge_reduction.value()); -} - -void QuoteLegPriceQuantityState::update_out_price_quantity(Price new_out_price, Quantity new_out_quantity) -{ - _out_price = new_out_price; - _out_quantity = new_out_quantity; -} - -Quantity QuoteLegPriceQuantityState::remaining_to_fill() const -{ - if (_aggregated_hedged_reduction.value() >= _in_target_leg_quantity.value()) - { - return Quantity(0); - } - else - { - Quantity hedge_reduced_target_quantity = Quantity(_in_target_leg_quantity.value() - _aggregated_hedged_reduction.value()); - if (_aggregated_filled_quantity.value() >= hedge_reduced_target_quantity.value()) - return Quantity(0); - else - return Quantity(hedge_reduced_target_quantity.value() - _aggregated_filled_quantity.value()); - } -} -}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/QuoteLegPriceQuantityState.h b/src/server/sparkd/spreader/QuoteLegPriceQuantityState.h index 2997eb1b4..ca83a0c80 100644 --- a/src/server/sparkd/spreader/QuoteLegPriceQuantityState.h +++ b/src/server/sparkd/spreader/QuoteLegPriceQuantityState.h @@ -15,46 +15,74 @@ private: // modifies the price of the spread order Price _in_target_spread_price; // this is total desired leg quantity set by the user. - // it is simply the spread leg qty * leg_ratio + // ( = spread target qty * leg_ratio) it is only + // modfified when the when the user explicitely changes it Quantity _in_target_leg_quantity; // sum of the fills for this leg. as fills come in // this increases Quantity _aggregated_filled_quantity; // when fills happen for the other legs, the "equivelant part" // is deducted from the quoted quantity and sent over - // to the hedger. This is the sum of those of those "equivelant parts". - // for example with with a a*leg_1 - b*leg_2, spread an N lot sized - // fill on leg_2 will will result in N*a/b added to _aggregated_hedged_reduction + // to the hedger. This is the sum of those "equivelant parts". + // for example for a spread: a*leg_1 - b*leg_2 an N lot + // sized fill on leg_2 will will result in N*a/b added + // to _aggregated_hedged_reduction Quantity _aggregated_hedged_reduction; // price of the last order sent. Price _out_price; // quantity of the last order sent Quantity _out_quantity; public: - QuoteLegPriceQuantityState(Price target_spread_price, Quantity target_leg_quantity); - // called when the user changes the spread price - void update_target_spread_price(Price new_target_spread_price); - // called when the target quantity of the spreader order is changed. - // this is only called as a result of the user user changing the - // spreader order qty - void update_target_leg_quantity(Quantity new_target_leg_quantity); + QuoteLegPriceQuantityState(Price target_spread_price, Quantity target_leg_quantity) + : + _in_target_spread_price(target_spread_price), + _in_target_leg_quantity(target_leg_quantity), + _aggregated_filled_quantity(0), + _aggregated_hedged_reduction(0), + _out_quantity(0) + {} + // when the user changes the spread price + void update_target_spread_price(Price new_target_spread_price) + { _in_target_spread_price = new_target_spread_price; } + // when the user changes the spread price + void update_target_leg_quantity(Quantity new_target_leg_quantity) + { _in_target_leg_quantity = new_target_leg_quantity; } // called when a fill happens for this leg. this increases the filled counter. // this is needed to know the "remainder quantity" needed to price this leg - void add_filled_quantity(Quantity filled_qty); + void add_filled_quantity(Quantity filled_qty) + {_aggregated_filled_quantity = Quantity(_aggregated_filled_quantity.value() + filled_qty.value());} // updates the filled quantity as a whole (vs adding increments) - void update_filled_quantity(Quantity total_filled_quantity); + void update_filled_quantity(Quantity total_filled_quantity) + { _aggregated_filled_quantity = Quantity(total_filled_quantity); } // called when a fill happens in one of the other quoting legs. - void add_hedged_reduction(Quantity normalized_hedge_qty); + void add_hedged_reduction(Quantity normalized_hedge_reduction) + {_aggregated_hedged_reduction = Quantity(_aggregated_hedged_reduction.value() + normalized_hedge_reduction.value());} // updates the out price and quantity - void update_out_price_quantity(Price new_computed_price, Quantity new_computed_quantity); - // Accessor functions + void update_out_price_quantity(Price new_out_price, Quantity new_out_quantity) + { + _out_price = new_out_price; + _out_quantity = new_out_quantity; + } + // const accessor functions Price target_spread_price() const { return _in_target_spread_price; } Quantity target_leg_quantity() const { return _in_target_leg_quantity; } Quantity aggregated_filled_quantity() const { return _aggregated_filled_quantity; } Quantity aggregated_hedged_reduction() const { return _aggregated_hedged_reduction; } Price out_price() const { return _out_price; } Quantity out_quantity() const { return _out_quantity; } - Quantity remaining_to_fill() const; + Quantity remaining_to_fill() const + { + if (_aggregated_hedged_reduction.value() >= _in_target_leg_quantity.value()) + return Quantity(0); + else + { + Quantity hedge_reduced_target_quantity = Quantity(_in_target_leg_quantity.value() - _aggregated_hedged_reduction.value()); + if (_aggregated_filled_quantity.value() >= hedge_reduced_target_quantity.value()) + return Quantity(0); + else + return Quantity(hedge_reduced_target_quantity.value() - _aggregated_filled_quantity.value()); + } + } bool target_reached () const {return remaining_to_fill().value() == 0; } }; }} diff --git a/src/server/sparkd/spreader/SingleLegQuoter.cpp b/src/server/sparkd/spreader/SingleLegQuoter.cpp index 7655f5330..bbe4b852a 100644 --- a/src/server/sparkd/spreader/SingleLegQuoter.cpp +++ b/src/server/sparkd/spreader/SingleLegQuoter.cpp @@ -9,421 +9,103 @@ namespace bts { namespace orderman { -SingleLegQuoter::SingleLegQuoter(ISpreaderManager& order_bridge, +SingleLegQuoter::SingleLegQuoter(ISpreaderManager& spreader, LegPropertyData this_leg_property, size_t n_spreader_legs, bts::Price spread_order_price, bts::Quantity spread_order_quantity, bts::orderman::SpreaderOrderBase::ChildOrder child_order) : - _tick_size(this_leg_property.tick_size()), _two_legged (n_spreader_legs == 2), - _order_bridge(order_bridge), + _spreader(spreader), _this_leg_data (this_leg_property), - _this_leg_index(this_leg_property.leg_index), _n_spreader_legs (n_spreader_legs), - _child_order (child_order), - _state(QuoterState::START), - _price_quantity_state(QuoteLegPriceQuantityState(spread_order_price, Quantity(static_cast(spread_order_quantity.value() * _this_leg_data.size_multiplier())))) + _order (child_order), + _price_quantity_state(QuoteLegPriceQuantityState(spread_order_price, Quantity(static_cast(spread_order_quantity.value() * _this_leg_data.size_multiplier())))), + _worker(nullptr) + //_time_stamp (0) // TODO { for (size_t q_idx = 0; q_idx < _n_spreader_legs; q_idx++) _aux_comp_data.push_back(PQPair()); + _transform_to_START (); } - +/*********************************************************************************/ +/*********************************spreader calls**********************************/ +/*********************************************************************************/ void SingleLegQuoter::init() { - _tranform_to_WAITING_FOR_MARKET(); + LOG(OrderMan, Diag, "SingleLegQuoter::init key: {}", _order.order_key().value()); + _worker->init(); } - -bool SingleLegQuoter::is_active_order() const { return _state == QuoterState::WAITING_FOR_FIRST_ACK || _state == QuoterState::WORKING || _state == QuoterState::WAITING_FOR_CANCEL_ACK_FINAL; } - -bool SingleLegQuoter::is_terminal_state () const {return _state == QuoterState::END;} - -bool SingleLegQuoter::accept_modifications() const { return _state == QuoterState::WAITING_FOR_SIZE || _state == QuoterState::WORKING; } - -std::string state_name(QuoterState state) { - switch (state) { - case QuoterState::START: - return "START"; - case QuoterState::WAITING_FOR_SIZE: - return "WAITING_FOR_SIZE"; - case QuoterState::WAITING_FOR_FIRST_ACK: - return "WAITING_FOR_FIRST_ACK"; - case QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED: - return "WAITING_FOR_FIRST_ACK_CANCELLED"; - case QuoterState::WORKING: - return "WORKING"; - case QuoterState::WAITING_FOR_CANCEL_ACK_FINAL: - return "WAITING_FOR_CANCEL_ACK_FINAL"; - case QuoterState::WAITING_FOR_CANCEL_ACK_CONTINUE: - return "WAITING_FOR_CANCEL_ACK_CONTINUE"; - case QuoterState::END: - return "END"; - } - return ""; -} - -void SingleLegQuoter::update_order_status(const SpreaderOrderUpdateMessage& order_update_message) +void SingleLegQuoter::update_order_status(const SpreaderOrderUpdateMessage& u) { - LOG(OrderMan,Diag,"Updating quoter order status. Key {} State {}", _child_order.order_key().value(), - state_name(_state)); - - EventData ev; - ev.order_update(&order_update_message); - _fire_event(ev); + LOG(OrderMan, Diag, "SingleLegQuoter::update_order_status key: {} state: {} order status: {} fills: {}", + _order.order_key().value(), _worker->state_text(), static_cast(u.status()), u.last_update_filled_quantity().value()); + _worker->on_order_update (u); } - -void SingleLegQuoter::update_md(orderman::TickToTradeCorID cid, size_t leg_index) +void SingleLegQuoter::on_book(orderman::TickToTradeCorID cid, size_t leg_index, const bts::orderman::Book& book) { - EventData ev; - ev.md_update(cid,leg_index); - _fire_event(ev); + _worker->on_book (cid, leg_index, book); } - -void SingleLegQuoter::update_other_leg_fills(size_t, Quantity filled_quantity) +void SingleLegQuoter::update_other_leg_fills(size_t leg_index, Quantity filled_quantity) { - EventData ev; - // TODO, normalize this - ev.other_leg_fill_update(filled_quantity); - _fire_event(ev); + LOG(OrderMan, Diag, "SingleLegQuoter::update_other_leg_fills key: {} state: {} leg_index: {} filled_quantity: {}", + _order.order_key().value(), _worker->state_text(), leg_index, filled_quantity.value()); + _worker->other_leg_quoter_fill (leg_index, filled_quantity); } - -void SingleLegQuoter::update_order_price_quantity(Price new_price, Quantity new_quantity) +void SingleLegQuoter::update_order_price_quantity(Price price, Quantity quantity) { - EventData ev; - ev.price_quantity_update(new_price, new_quantity); - _fire_event(ev); + Quantity this_leg_quantity = Quantity (SpreaderUtils::get_leg_quantity_from_spreader_quantity (_this_leg_data, quantity)); + LOG(OrderMan, Diag, "SingleLegQuoter::update_order_price_quantity key: {} state: {} price: {} spread quantity: {} leg quantity: {}", + _order.order_key().value(), _worker->state_text(), price.value(), quantity.value(), this_leg_quantity.value()); + _worker->update_spreader_order (price, this_leg_quantity); } - void SingleLegQuoter::cancel_order() { - EventData ev; - ev.cancel_order(); - _fire_event(ev); + LOG(OrderMan, Diag, "SingleLegQuoter::cancel_order key: {}, state: {}", _order.order_key().value(), _worker->state_text()); + _worker->cancel (); } - -void SingleLegQuoter::on_time (const bts::TimeStamp&) {} - -/**********************************************************************/ -/************External Event Handling in START**************************/ -/**********************************************************************/ - -void SingleLegQuoter::_handle_events_in_START(const EventData&) +void SingleLegQuoter::terminate () { - // as soon as the class initializes it moves out of the START - // state. no events should be received in this state - bts_assert(false); + LOG(OrderMan, Diag, "SingleLegQuoter::terminate key: {}, state: {}", _order.order_key().value(), _worker->state_text()); + _worker->terminate (); } - -/**********************************************************************/ -/************External Event Handling in WAITING FOR MARKET*************/ -/**********************************************************************/ - -void SingleLegQuoter::_tranform_to_WAITING_FOR_MARKET() +void SingleLegQuoter::on_time (const bts::TimeStamp& ts) { - bts_assert(_state == QuoterState::START); - _state = QuoterState::WAITING_FOR_SIZE; + _time_stamp = ts; + _worker->on_time (ts); } - -void SingleLegQuoter::_check_md_in_WAITING_FOR_MARKET() +bool SingleLegQuoter::is_active_order() const { - Price price; Quantity quantity; - _compute_price_quantity(price, quantity); - if (quantity.value() > 0) - _tranform_to_WAITING_FOR_FIRST_ACK(); + QuoterState state = _worker->state(); + return state == QuoterState::WAITING_FOR_FIRST_ACK || state == QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED || + state == QuoterState::WORKING || state == QuoterState::WAITING_FOR_CANCEL_ACK_FINAL || state == QuoterState::WAITING_FOR_CANCEL_ACK_CONTINUE; } - -void SingleLegQuoter::_handle_events_in_WAITING_FOR_MARKET(const EventData& event_data) -{ - if (event_data.external_event == ExternalEvents::OrderStateUpdate) - bts_assert(false); - else if (event_data.external_event == ExternalEvents::MDUpdate) - { - //_leg_data.at(event_data.book_leg_index).book = event_data.book; - _check_md_in_WAITING_FOR_MARKET(); - } - else if (event_data.external_event == ExternalEvents::OtherLegQuotingFill) - { - _price_quantity_state.add_hedged_reduction(event_data.other_leg_filled_quanity); - if (_price_quantity_state.remaining_to_fill().value() == 0) - // if the size is changed such that hedge redution has made - // the remainder 0, we dont need to quote this leg - _transform_to_END(); - else - // evaluating quantity again, because the reduced size requirements - // may mean that we have enough size available in the other legs - _check_md_in_WAITING_FOR_MARKET(); - } - else if (event_data.external_event == ExternalEvents::SpreadPriceQuantityChange) - { - _price_quantity_state.update_target_spread_price(event_data.new_spread_price); - _price_quantity_state.update_target_leg_quantity(event_data.new_leg_quantity); - if (_price_quantity_state.remaining_to_fill().value() == 0) - // if the size is changed such that hedge redution has made - // the remainder 0, we dont need to quote this leg - _transform_to_END(); - else - _check_md_in_WAITING_FOR_MARKET(); - } - else if (event_data.external_event == ExternalEvents::CancelOrder) - { - // no order has been sent for this leg, but the spreader order - // is cancelled. - _transform_to_END(); - } -} -/********************************************************************************/ -/*****************External Event Handling in WAITING_FOR_FIRST_ACK***************/ -/********************************************************************************/ - -void SingleLegQuoter::_tranform_to_WAITING_FOR_FIRST_ACK() -{ - bts_assert(_state == QuoterState::WAITING_FOR_SIZE); - _state = QuoterState::WAITING_FOR_FIRST_ACK; - bts_assert(_price_quantity_state.aggregated_filled_quantity().value() == 0); - bts_assert(_price_quantity_state.out_quantity().value() == 0); - Price price; Quantity quantity; - _compute_price_quantity(price, quantity); - bts_assert(quantity.value() > 0); - _price_quantity_state.update_out_price_quantity(price, quantity); - // This is the first and only time a quoting order is sent - _child_order.create(bts::orderman::NullTickToTradeCorID, _price_quantity_state.out_price(), _price_quantity_state.out_quantity()); -} - -void SingleLegQuoter::_handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data) -{ - if (event_data.external_event == ExternalEvents::OrderStateUpdate) - { - const SpreaderOrderUpdateMessage& order_udpate_message = *(event_data.order_update_message); - _price_quantity_state.update_filled_quantity(order_udpate_message.filled_quantity()); - if (order_udpate_message.terminal_status()) - _transform_to_END(); - else if (order_udpate_message.has_error()) - // TODO, spreader is already checking for this - // and cancelling orders - _transform_to_WAITING_FOR_CANCEL_ACK(); - else if (order_udpate_message.acknowledged()) - { - if (_price_quantity_state.remaining_to_fill().value() == 0) - _transform_to_WAITING_FOR_CANCEL_ACK(); - else - // this is the working state - // TODO, check for ack (there can be an un ack'ed state) - _transform_to_WORKING(); - } - } - else if (event_data.external_event == ExternalEvents::MDUpdate) - { - // nothing to do, we just wait for a working order status - } - else if (event_data.external_event == ExternalEvents::OtherLegQuotingFill) - { - _price_quantity_state.add_hedged_reduction(event_data.other_leg_filled_quanity); - if (_price_quantity_state.remaining_to_fill().value() == 0) - _transform_to_WAITING_FOR_CANCEL_ACK(); - } - else if (event_data.external_event == ExternalEvents::SpreadPriceQuantityChange) - { - // price/quantity changes are not allowed in this state, accept_modifications - // should have returned false and disallowed this call to happen - bts_assert(false); - } - else if (event_data.external_event == ExternalEvents::CancelOrder) - { - _transform_to_WAITING_FOR_CANCEL_ACK(); - } -} - -/********************************************************************************/ -/**********************External Event Handling in WORKING************************/ -/********************************************************************************/ - -// void SingleLegQuoter::_transform_to_WORKING() -// { -// bts_assert(_state == QuoterState::WAITING_FOR_FIRST_ACK); -// _state = QuoterState::WORKING; -// LOG(OrderMan,Diag,"Transitioning SingleLegQuoter {} to state {}", -// _child_order.order_key().value(), -// state_name(_state)); -// } - -void SingleLegQuoter::_reprice_in_WORKING(orderman::TickToTradeCorID cid) -{ - // TODO: dont change state here, make state changing more explicit - Price new_price; Quantity new_quantity; - _compute_price_quantity(new_price, new_quantity); - if (new_quantity.value() == 0) - // the other legs dried up, so the quanity gets - // computed to be 0 - _transform_to_WAITING_FOR_CANCEL_ACK(); - else - { - // adjusted for the fills, since _compute_price_quantity - // is computed on the remainder - new_quantity = Quantity(new_quantity.value() + _price_quantity_state.aggregated_filled_quantity().value()); - if (new_quantity.value() != _price_quantity_state.out_quantity().value()) - { - _price_quantity_state.update_out_price_quantity(new_price, new_quantity); - _child_order.update(bts::orderman::NullTickToTradeCorID, new_price, new_quantity); - } - else - { - bool reprice = true; - if (_this_leg_data.leg_params.quote_params().has_quote_mute_zone()) - reprice = SpreaderUtils::reprice_quote_mute_zone(_price_quantity_state.out_price().value(), new_price.value(), _this_leg_data.trading_side, _tick_size, _this_leg_data.leg_params.quote_params().quote_mute_zone()); - if (reprice) - { - _price_quantity_state.update_out_price_quantity(new_price, new_quantity); - _child_order.update(cid,new_price, new_quantity); - } - } - } -} - -void SingleLegQuoter::_handle_events_in_WORKING(const EventData& event_data) -{ - if (event_data.external_event == ExternalEvents::OrderStateUpdate) - { - LOG(OrderMan,Diag,"Updating quoting order {} in working state",_child_order.order_key().value()); - - const SpreaderOrderUpdateMessage& order_update_message = *(event_data.order_update_message); - _price_quantity_state.update_filled_quantity(order_update_message.filled_quantity()); - if (order_update_message.terminal_status()) - _transform_to_END(); - else if (order_update_message.has_error()) - _transform_to_WAITING_FOR_CANCEL_ACK(); - else - { - // normal state - if (order_update_message.has_fills ()) - { - if (_price_quantity_state.remaining_to_fill().value() == 0) - _transform_to_WAITING_FOR_CANCEL_ACK(); - else - _reprice_in_WORKING(orderman::NullTickToTradeCorID); - } - else - { - // this is the normal state - } - } - } - else if (event_data.external_event == ExternalEvents::MDUpdate) - { - _reprice_in_WORKING(event_data.cid); - } - else if (event_data.external_event == ExternalEvents::OtherLegQuotingFill) - { - _price_quantity_state.add_hedged_reduction(event_data.other_leg_filled_quanity); - if (_price_quantity_state.remaining_to_fill().value() == 0) - _transform_to_WAITING_FOR_CANCEL_ACK(); - else - _reprice_in_WORKING(orderman::NullTickToTradeCorID); - } - else if (event_data.external_event == ExternalEvents::SpreadPriceQuantityChange) - { - _price_quantity_state.update_target_spread_price(event_data.new_spread_price); - _price_quantity_state.update_target_leg_quantity(event_data.new_leg_quantity); - if (_price_quantity_state.remaining_to_fill().value() == 0) - _transform_to_WAITING_FOR_CANCEL_ACK(); - else - _reprice_in_WORKING(orderman::NullTickToTradeCorID); - } - else if (event_data.external_event == ExternalEvents::CancelOrder) - { - _transform_to_WAITING_FOR_CANCEL_ACK(); - } -} - -/********************************************************************************/ -/*****************External Event Handling in WAITING_FOR_CANCEL_ACK**************/ -/********************************************************************************/ - -void SingleLegQuoter::_transform_to_WAITING_FOR_CANCEL_ACK() -{ - bts_assert(_state == QuoterState::WAITING_FOR_FIRST_ACK || _state == QuoterState::WORKING); - _state = QuoterState::WAITING_FOR_CANCEL_ACK_FINAL; - // this is only place where the order is cancelled - _child_order.cancel(); -} - -void SingleLegQuoter::_handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data) -{ - if (event_data.external_event == ExternalEvents::OrderStateUpdate) - { - const SpreaderOrderUpdateMessage& order_udpate_message = *(event_data.order_update_message); - _price_quantity_state.update_filled_quantity(order_udpate_message.filled_quantity()); - if (order_udpate_message.terminal_status()) - _transform_to_END(); - } - else if (event_data.external_event == ExternalEvents::MDUpdate) - { - // nothing to do, we just wait for a cancel ack - } - else if (event_data.external_event == ExternalEvents::OtherLegQuotingFill) - { - _price_quantity_state.add_hedged_reduction(event_data.other_leg_filled_quanity); - } - else if (event_data.external_event == ExternalEvents::SpreadPriceQuantityChange) - { - // price/qty changes are not allowed in this state, accept_modifications - // shoudl have returned false and disallowed this call to happen - bts_assert(false); - } - else if (event_data.external_event == ExternalEvents::CancelOrder) - { - // already cancelled - } -} - -/********************************************************************************/ -/************************External Event Handling in END**************************/ -/********************************************************************************/ - -// void SingleLegQuoter::_transform_to_END() -// { -// bts_assert(_state == QuoterState::WAITING_FOR_FIRST_ACK || _state == QuoterState::WORKING || -// _state == QuoterState::WAITING_FOR_CANCEL_ACK); -// _state = QuoterState::END; -// } - -void SingleLegQuoter::_handle_events_in_END(const EventData & event_data) -{ - if (event_data.external_event == ExternalEvents::OrderStateUpdate) - bts_assert(false); -} - +bool SingleLegQuoter::is_terminal_state () const {return _worker->state() == QuoterState::END;} +bool SingleLegQuoter::accept_modifications() const { return _worker->state() == QuoterState::WAITING_FOR_SIZE || _worker->state() == QuoterState::WORKING; } void SingleLegQuoter::_incorporate_other_leg_fill (size_t leg_index, Quantity filled_quantity) { - bts_assert (leg_index != _this_leg_index); - double this_leg_reduction_d = _get_equivelant_quantity_from_other_leg (leg_index, filled_quantity); - Quantity this_leg_reduction = Quantity (this_leg_reduction_d); - _price_quantity_state.add_hedged_reduction (this_leg_reduction); + double this_leg_reduction_d = SpreaderUtils::get_equivelant_size (_spreader.get_leg_data(leg_index), filled_quantity, _this_leg_data); + _price_quantity_state.add_hedged_reduction (Quantity (this_leg_reduction_d)); } - -void SingleLegQuoter::_fire_event(const EventData& event_data) +void SingleLegQuoter::_compute_price_quantity(Price& price, Quantity& quantity) { - if (_state == QuoterState::WORKING) - _handle_events_in_WORKING(event_data); - else if (_state == QuoterState::START) - _handle_events_in_START(event_data); - else if (_state == QuoterState::WAITING_FOR_SIZE) - _handle_events_in_WAITING_FOR_MARKET(event_data); - else if (_state == QuoterState::WAITING_FOR_FIRST_ACK) - _handle_events_in_WAITING_FOR_FIRST_ACK(event_data); - else if (_state == QuoterState::WAITING_FOR_CANCEL_ACK_FINAL) - _handle_events_in_WAITING_FOR_CANCEL_ACK(event_data); + if (_two_legged) + { + size_t other_leg_index = _this_leg_data.leg_index == 0 ? 1 : 0; + SpreaderUtils::compute_price_quantity_2_legs (_price_quantity_state, _this_leg_data, _spreader.get_leg_data(other_leg_index), _spreader.get_book(other_leg_index), price, quantity); + } + else _compute_price_quantity_n_legs (price, quantity); } - void SingleLegQuoter::_compute_price_quantity_n_legs(Price& price, Quantity& quantity) { size_t min_quoter_leg_quantity_index = 0; for (size_t idx = 0; idx < _n_spreader_legs; idx++) { - if (idx != _this_leg_index) + if (idx != _this_leg_data.leg_index) { - const orderman::Book& other_leg_book = _order_bridge.get_book(idx); - const LegPropertyData& other_leg_data = _order_bridge.get_leg_data(idx); + const orderman::Book& other_leg_book = _spreader.get_book(idx); + const LegPropertyData& other_leg_data = _spreader.get_leg_data(idx); Price other_leg_calc_price; Quantity other_leg_calc_quantity, this_leg_calc_quantity; Quantity this_leg_target_quantity = _price_quantity_state.remaining_to_fill(); double other_leg_total_lean_ratio = other_leg_data.leg_params.quote_params().lean_quantity_ratio() * other_leg_data.size_multiplier() / _this_leg_data.size_multiplier(); @@ -439,103 +121,69 @@ void SingleLegQuoter::_compute_price_quantity_n_legs(Price& price, Quantity& qua quantity = _aux_comp_data.at(min_quoter_leg_quantity_index).quoter_leg_quantity; price = _compute_leg_price_n_legs(_aux_comp_data); } - Price SingleLegQuoter::_compute_leg_price_n_legs(const std::vector& leg_values) { double sum = 0; for (size_t idx = 0; idx < _n_spreader_legs; idx++) { - if (idx != _this_leg_index) + if (idx != _this_leg_data.leg_index) { const PQPair& leg_pq_pair = leg_values[idx]; - const LegPropertyData& leg_data = _order_bridge.get_leg_data (idx); + const LegPropertyData& leg_data = _spreader.get_leg_data (idx); sum += leg_pq_pair.leg_price.value() * leg_data.price_multiplier(); } } double rv = _price_quantity_state.target_spread_price().value() - sum; /// TODO, needs a divisor return Price(rv); } - -void SingleLegQuoter::_compute_price_quantity_2_legs(Price& price, Quantity& quantity) -{ - size_t other_leg_index = _this_leg_index == 0 ? 1 : 0; - const orderman::Book& other_leg_book = _order_bridge.get_book(other_leg_index); - const LegPropertyData& other_leg_data = _order_bridge.get_leg_data(other_leg_index); - Price other_leg_calc_price; Quantity other_leg_calc_quantity; - Quantity this_leg_target_quantity = _price_quantity_state.remaining_to_fill(); - double other_leg_total_lean_ratio = other_leg_data.leg_params.quote_params().lean_quantity_ratio() * other_leg_data.size_multiplier() / _this_leg_data.size_multiplier(); - double other_leg_target_quantity = this_leg_target_quantity.value() * other_leg_total_lean_ratio; - SpreaderUtils::traverse_depth_for_quantity(other_leg_book, SpreaderUtils::invert_side (other_leg_data.trading_side), Quantity(other_leg_target_quantity), other_leg_calc_price, other_leg_calc_quantity); - quantity = Quantity(static_cast(1.0 /*TODOit->lean_ratio*/ * other_leg_calc_quantity.value())); // TODO - price = Price((_price_quantity_state.target_spread_price().value() - other_leg_calc_price.value() * other_leg_data.price_multiplier())/_this_leg_data.price_multiplier()); -} - -double SingleLegQuoter::_get_equivelant_quantity_from_spreader_quantity (Quantity) -{ - return 0.0; -} - -double SingleLegQuoter::_get_equivelant_quantity_from_other_leg(size_t leg_index, Quantity quantity) -{ - const LegPropertyData& leg_data = _order_bridge.get_leg_data(leg_index); - const LegPropertyData& this_leg_data = _order_bridge.get_leg_data(_this_leg_index); - return static_cast (quantity.value() * this_leg_data.leg_contract.quantity() / leg_data.leg_contract.quantity()); -} - +/*********************************************************************************/ +/*******************************state transformations*****************************/ +/*********************************************************************************/ void SingleLegQuoter::_transform_to_START () { bts_assert (_worker == nullptr); - _worker = &_start_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_START key: {}", _child_order.order_key().value()); - _worker->build_once (this); + _switch_state (&_start_state_worker); } void SingleLegQuoter::_transform_to_WAITING_FOR_SIZE () { bts_assert (_worker->state() == QuoterState::START || _worker->state() == QuoterState::WAITING_FOR_CANCEL_ACK_CONTINUE); - _worker = &_waiting_for_size_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_WAITING_FOR_SIZE key: {}", _child_order.order_key().value()); - _worker->build_once (this); + _switch_state (&_waiting_for_size_state_worker); } void SingleLegQuoter::_transform_to_WAITING_FOR_FIRST_ACK () { bts_assert (_worker->state() == QuoterState::WAITING_FOR_SIZE); - _worker = &_waiting_for_first_ack_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_WAITING_FOR_FIRST_ACK key: {}", _child_order.order_key().value()); - _worker->build_once (this); + _switch_state (&_waiting_for_first_ack_state_worker); } void SingleLegQuoter::_transform_to_WAITING_FOR_FIRST_ACK_CANCELLED() { bts_assert (_worker->state() == QuoterState::WAITING_FOR_FIRST_ACK); - _worker = &_waiting_for_first_ack_cancelled_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_WAITING_FOR_FIRST_ACK_CANCELLED key: {}", _child_order.order_key().value()); - _worker->build_once (this); + _switch_state (&_waiting_for_first_ack_cancelled_state_worker); } void SingleLegQuoter::_transform_to_WORKING() { bts_assert (_worker->state() == QuoterState::WAITING_FOR_FIRST_ACK); - _worker = &_working_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_WORKING key: {}", _child_order.order_key().value()); - _worker->build_once (this); + _switch_state (&_working_state_worker); } void SingleLegQuoter::_transform_to_WAITING_FOR_CANCEL_ACK_FINAL() { - bts_assert (_worker->state() == QuoterState::WORKING); - _worker = &_waiting_for_cancel_ack_final_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_WAITING_FOR_CANCEL_ACK_FINAL key: {}", _child_order.order_key().value()); - _worker->build_once (this); + bts_assert (_worker->state() == QuoterState::WORKING || _worker->state() == QuoterState::WAITING_FOR_FIRST_ACK); + _switch_state (&_waiting_for_cancel_ack_final_state_worker); } void SingleLegQuoter::_transform_to_WAITING_FOR_CANCEL_ACK_CONTINUE() { bts_assert (_worker->state() == QuoterState::WORKING); - _worker = &_waiting_for_cancel_ack_return_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_WAITING_FOR_CANCEL_ACK_CONTINUE key: {}", _child_order.order_key().value()); + _switch_state (&_waiting_for_cancel_ack_continue_state_worker); +} +void SingleLegQuoter::_transform_to_END() +{ + bts_assert (_worker->state() != QuoterState::END); + _switch_state (&_end_state_worker); +} +void SingleLegQuoter::_switch_state (IQuoterStateWorker* new_state) +{ + LOG(OrderMan, Diag, "SingleLegQuoter::_switch_state key: {}, {} -> {} ", _order.order_key().value(), (_worker == nullptr ? "NULL" : _worker->state_text()), new_state->state_text()); + _worker = new_state; _worker->build_once (this); } -void SingleLegQuoter::_transform_to_END(){ - bts_assert (_worker->state() != QuoterState::END); - _worker = &_end_state_worker; - LOG(OrderMan, Diag, "SingleLegQuoter::_transform_to_END key: {}", _child_order.order_key().value()); - _worker->build_once (this); -} -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/spreader/SingleLegQuoter.h b/src/server/sparkd/spreader/SingleLegQuoter.h index c1bcd14eb..5e2651958 100644 --- a/src/server/sparkd/spreader/SingleLegQuoter.h +++ b/src/server/sparkd/spreader/SingleLegQuoter.h @@ -25,94 +25,7 @@ class ISpreaderManager; class SpreaderOrderUpdateMessage; class SingleLegQuoter { - // this represents all signals generated - // esternally that the quoter is interested in - enum class ExternalEvents - { - // order update could be status updates or fills - OrderStateUpdate, - // market data update from the exchanges - MDUpdate, - // fill on another leg - OtherLegQuotingFill, - // price/quantity and/or change - SpreadPriceQuantityChange, - // cancel of this leg order (automatic or manual) - CancelOrder, - }; -public: - // // the states of the quoter state machine - // enum class QuoterState - // { - // // start state. there is a transient state, no - // // event processing happens in this state. as soon - // // as the quoter sees the init, it goes to - // // waiting_for_market - // START = 0, - // // start goes to waiting_for_market as soon as the - // // quoter is initialized. here it waits for the - // // market data in the other legs to be available - // // so that it can price itself (it's leg), and move - // // to waiting_for_first_ack - // WAITING_FOR_MARKET, - // // the transition to this state is accompanied by - // // submitting an order. it waits here till it gets - // // an order ack (of any kind) and moves to working - // WAITING_FOR_FIRST_ACK, - // // this is the main working state - // WORKING, - // // transition to this state is accompanied by cancelling - // // the order. it waits in this state till it gets an - // // order state signalling a terminal state - // WAITING_FOR_CANCEL_ACK, - // // there are no working orders in this state. - // END - // }; private: - // the external events and data are packaged into - // this class and sent over to the state machine. - // depending on the value of the external_event, - // different parts of this class are lightened up - // (not very pretty, maybe std variant could be used) - class EventData - { - public: - ExternalEvents external_event; - SpreaderOrderUpdateMessage const* order_update_message; - size_t book_leg_index; - Price new_spread_price; - Quantity new_leg_quantity; - Quantity other_leg_filled_quanity; - orderman::TickToTradeCorID cid; - - void order_update(SpreaderOrderUpdateMessage const* arg) - { - external_event = ExternalEvents::OrderStateUpdate; - order_update_message = arg; - } - void md_update(orderman::TickToTradeCorID cid, size_t arg) - { - this->cid = cid; - external_event = ExternalEvents::MDUpdate; - book_leg_index = arg; - } - void price_quantity_update(Price price_arg, Quantity quantity_arg) - { - external_event = ExternalEvents::SpreadPriceQuantityChange; - new_spread_price = price_arg; - new_leg_quantity = quantity_arg; - } - void other_leg_fill_update(Quantity fill_arg) - { - external_event = ExternalEvents::OtherLegQuotingFill; - other_leg_filled_quanity = fill_arg; - } - void cancel_order() - { - external_event = ExternalEvents::CancelOrder; - } - }; - struct PQPair { public: @@ -133,16 +46,15 @@ private: } }; private: - const double _tick_size; const bool _two_legged; - ISpreaderManager& _order_bridge; + const ISpreaderManager& _spreader; const LegPropertyData _this_leg_data; - const size_t _this_leg_index; const size_t _n_spreader_legs; - bts::orderman::SpreaderOrderBase::ChildOrder _child_order; + bts::orderman::SpreaderOrderBase::ChildOrder _order; std::vector _aux_comp_data; - QuoterState _state; QuoteLegPriceQuantityState _price_quantity_state; + bts::TimeStamp _time_stamp; + // state workers IQuoterStateWorker* _worker; QuoterStartStateWorker _start_state_worker; QuoterWaitingForSizeStateWorker _waiting_for_size_state_worker; @@ -150,7 +62,7 @@ private: QuoterWaitingForFirstAckCancelledWorker _waiting_for_first_ack_cancelled_state_worker; QuoterWaitingForCancelAckFinalStateWorker _waiting_for_cancel_ack_final_state_worker; QuoterWorkingStateWorker _working_state_worker; - QuoterWaitingForCancelAckReturnStateWorker _waiting_for_cancel_ack_return_state_worker; + QuoterWaitingForCancelAckReturnStateWorker _waiting_for_cancel_ack_continue_state_worker; QuoterEndStateWorker _end_state_worker; public: SingleLegQuoter(ISpreaderManager& order_bridge, @@ -179,7 +91,7 @@ public: void update_order_status(const SpreaderOrderUpdateMessage& order_update_message); // called when the market data associated // with this security is changed - void update_md(orderman::TickToTradeCorID cid,size_t leg_index); + void on_book(orderman::TickToTradeCorID cid,size_t leg_index, const bts::orderman::Book&); // this is called by the spreader when a quoting fill // (ie not hedging fill) happens on one of the quoting // legs @@ -190,10 +102,10 @@ public: // manually or automatically void cancel_order(); // the quoter forgets everything and goes to the end state - void terminate () {_transform_to_END();} + void terminate (); // for test reasons void on_time(const bts::TimeStamp&); - QuoterState test_only_func_state() { return _state; } + QuoterState test_only_func_state() { return _worker->state (); } const QuoteLegPriceQuantityState& test_only_func_price_quantity_state () const {return _price_quantity_state;} friend QuoterStartStateWorker; friend QuoterWaitingForSizeStateWorker; @@ -204,52 +116,18 @@ public: friend QuoterWaitingForCancelAckReturnStateWorker; friend QuoterEndStateWorker; private: - /********************External Event Handling in START***********************/ - void _handle_events_in_START(const EventData& event_data); - /*************External Event Handling in WAITING_FOR_MARKET*****************/ - void _tranform_to_WAITING_FOR_MARKET(); - // using the market of the other legs, computes the - // quoting price and quantity, and if the quantity > 0 - // then it transforms to waiting_for_first_ack - void _check_md_in_WAITING_FOR_MARKET(); - void _handle_events_in_WAITING_FOR_MARKET(const EventData& event_data); - /*************External Event Handling in WAITING_FOR_FIRST_ACK*****************/ - void _tranform_to_WAITING_FOR_FIRST_ACK(); - void _handle_events_in_WAITING_FOR_FIRST_ACK(const EventData& event_data); - /*******************External Event Handling in WORKING*************************/ - void _reprice_in_WORKING(orderman::TickToTradeCorID cid); - void _handle_events_in_WORKING(const EventData& event_data); - /************External Event Handling in WAITING_FOR_CANCEL_ACK*****************/ - void _transform_to_WAITING_FOR_CANCEL_ACK(); - void _handle_events_in_WAITING_FOR_CANCEL_ACK(const EventData& event_data); - /**********************External Event Handling in END**************************/ - void _handle_events_in_END(const EventData& event_data); - /*******************************************************************************/ void _incorporate_other_leg_fill (size_t leg_index, Quantity filled_quantity); - // based on the state, calles the appropriate - // function to handle the event data - void _fire_event(const EventData& event_data); - // using the size ratios returns the size of this leg, corresponding - // to the size of an other leg. - double _get_equivelant_quantity_from_other_leg(size_t leg_index, Quantity quantity); // computes this leg quantity for the spreader order quantity - double _get_equivelant_quantity_from_spreader_quantity(Quantity quantity); + double _get_equivelant_quantity_from_spreader_quantity(Quantity) {return 0.0;} // this is the function that computes the quoting price and the // quantity for this leg. it uses the book of the other legs, // the lean ratio and the quoting parameters to come up with // the outgoing price and size. there is an n_leg case and an // optimized 2 leg case - void _compute_price_quantity(Price& price, Quantity& quantity) - { - if (_two_legged) _compute_price_quantity_2_legs (price, quantity); - else _compute_price_quantity_n_legs (price, quantity); - } + void _compute_price_quantity(Price& price, Quantity& quantity); void _compute_price_quantity_n_legs(Price& price, Quantity& quantity); // this is a helper function for the above. Price _compute_leg_price_n_legs(const std::vector& leg_values); - // this is an optimized case of "_compute_price_quantity" for - // a 2 legged spread - void _compute_price_quantity_2_legs(Price& price, Quantity& quantity); void _transform_to_START (); void _transform_to_WAITING_FOR_SIZE (); void _transform_to_WAITING_FOR_FIRST_ACK (); @@ -258,5 +136,6 @@ private: void _transform_to_WAITING_FOR_CANCEL_ACK_FINAL(); void _transform_to_WAITING_FOR_CANCEL_ACK_CONTINUE(); void _transform_to_END(); + void _switch_state (IQuoterStateWorker* new_state); }; }} diff --git a/src/server/sparkd/spreader/SpreaderBookkeepingData.h b/src/server/sparkd/spreader/SpreaderBookkeepingData.h index 3436d549c..7be548bdc 100644 --- a/src/server/sparkd/spreader/SpreaderBookkeepingData.h +++ b/src/server/sparkd/spreader/SpreaderBookkeepingData.h @@ -1,6 +1,7 @@ #pragma once #include #include +#include "server/sparkd/orderman/utils/orderman_utils.h" #include "SpreaderLegData.h" namespace bts{ @@ -13,20 +14,25 @@ class SpreaderBookkeepingData private: std::vector _leg_data; boost::container::flat_map _sec_key_to_index; + Price _price; + Quantity _quantity; public: - api::Security security; // TODO, move it out of here -public: - SpreaderBookkeepingData () {} - - SpreaderBookkeepingData(const api::Security& security_arg, const std::vector& leg_data) + SpreaderBookkeepingData () + : _leg_data (std::vector()), + _sec_key_to_index (boost::container::flat_map()), + _price (Price(0)), + _quantity (Quantity(0)) + {} + SpreaderBookkeepingData(const std::vector& leg_data, Price price, Quantity quantity) : _leg_data (leg_data), - security(security_arg) + _price (price), + _quantity (quantity) { for (auto it = leg_data.begin(); it != leg_data.end(); ++it) _sec_key_to_index.insert(std::pair(it->leg_property_data.security_key(), it->leg_property_data.leg_index)); } - SpreaderLegData& get_leg_data(SecurityKey security_key) + SpreaderLegData& get_leg_data (SecurityKey security_key) { boost::container::flat_map::const_iterator l_it = _sec_key_to_index.find(security_key.value()); bts_assert (l_it != _sec_key_to_index.end()); @@ -37,6 +43,11 @@ public: bts_assert(index < _leg_data.size()); return _leg_data[index]; } + const SpreaderLegData& get_leg_data (size_t index) const + { + bts_assert(index < _leg_data.size()); + return _leg_data[index]; + } size_t count() { return _leg_data.size(); } SpreaderLegData* find_leg_from_quoter_orderkey(orderman::OrderKey order_key) @@ -57,6 +68,13 @@ public: } return nullptr; } + Price price () {return _price;} + Quantity quantity () {return _quantity;} + void update_order (Price price, Quantity quantity) + { + _price = price; + _quantity = quantity; + } }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/SpreaderLegData.h b/src/server/sparkd/spreader/SpreaderLegData.h index 14bee4b18..af03354f4 100644 --- a/src/server/sparkd/spreader/SpreaderLegData.h +++ b/src/server/sparkd/spreader/SpreaderLegData.h @@ -34,10 +34,10 @@ public: _quoter (quoter_arg), _book(), _order_update_message (SpreaderOrderUpdateMessage (order_key)), - _hedger_data_vector() {} + _hedger_data_vector() {} SingleLegQuoter& quoter() {return _quoter;} - orderman::Book& book () {return _book;} + const orderman::Book& book () const {return _book;} // called for every book update. the values // are copied by value void set_book(const orderman::Book& book_arg) {_book = book_arg;} @@ -56,18 +56,17 @@ public: return nullptr; } // adds a new hedger with the given values -// SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager, -// size_t leg_index, -// const OrderTemplate& order_template, -// const LegPropertyData& leg_property_data, -// bts::Price hedge_price, -// bts::Quantity hedge_quantity, -// api::Side hedge_side) -// { -// SingleFillHedger hedger(spreader_manager, leg_index, order_template, leg_property_data, hedge_price, hedge_quantity, hedge_side); -// SpreaderHedgerData hedger_data(hedger); -// _hedger_data_vector.push_back(hedger_data); -// return _hedger_data_vector.back(); -// } + SpreaderHedgerData& add_new_hedger(ISpreaderManager& spreader_manager, + bts::orderman::SpreaderOrderBase::ChildOrder order, + bts::Price hedge_price, + bts::Quantity hedge_quantity, + api::Side hedge_side) + { + SpreaderOrderUpdateMessage hedger_order_update (order.order_key()); + SingleFillHedger hedger(spreader_manager, leg_property_data, order, hedge_price, hedge_quantity, hedge_side); + SpreaderHedgerData hedger_data(hedger, hedger_order_update); + _hedger_data_vector.push_back(hedger_data); + return _hedger_data_vector.back(); + } }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h b/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h index 5b184eb28..2ec9676d9 100644 --- a/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h +++ b/src/server/sparkd/spreader/SpreaderOrderUpdateMessage.h @@ -32,6 +32,7 @@ public: _last_update_filled_quantity(Quantity(0)), _has_error (false) { } + api::orderman::OrderStatus status () const {return _status;} Quantity filled_quantity () const {return _filled_quantity;} Price last_update_filled_price () const {return _last_update_filled_price;} Quantity last_update_filled_quantity () const {return _last_update_filled_quantity;} diff --git a/src/server/sparkd/spreader/SpreaderUtils.h b/src/server/sparkd/spreader/SpreaderUtils.h index 89fec5641..8e9fd9bc7 100644 --- a/src/server/sparkd/spreader/SpreaderUtils.h +++ b/src/server/sparkd/spreader/SpreaderUtils.h @@ -4,6 +4,8 @@ #include "lib/config/protos/MarketData.pb.h" #include "lib/md/Structure/PriceSize.h" #include "server/sparkd/orderman/md/Book.h" +#include "server/sparkd/spreader/LegPropertyData.h" +#include "server/sparkd/spreader/QuoteLegPriceQuantityState.h" namespace bts { namespace orderman { @@ -13,6 +15,9 @@ namespace orderman { class SpreaderUtils { public: + /**********************************************************************/ + /**************************General Spreader****************************/ + /**********************************************************************/ // finds the LegSpreaderParams for the leg specifies in arg 2 const static bts::spark::LegSpreaderParams& get_leg_params(const bts::spark::ExecutionStrategy& execution_strategy, const bts::api::ContractLeg& this_leg) @@ -32,7 +37,6 @@ public: return invert_side(quote_leg.side()); } // finds the index of a security in an key->index map - // ( bool static find_index(const boost::container::flat_map& key_to_index_map, uint32_t sec_key, size_t& out_index) { @@ -74,14 +78,31 @@ public: } bts_assert(false); } + // find the size of the target leg based on the size of the source leg. + // ex: for a spread s1.l1+s2.l2, a size N in l2 (so l2 is the source) + // corresponds to s1 * N / s2 size on l1 (target). + // so if we get an N lot fill in l2, we send a hedge on l1 + // sized s1 * N / s2 + static double get_equivelant_size (const LegPropertyData& source_leg, Quantity source_leg_quantity, + const LegPropertyData& target_leg) + { + return target_leg.size_multiplier () * source_leg_quantity.value () / source_leg.size_multiplier (); + } + // given the quantity of the spreader order, determines the quality + // of the leg + static double get_leg_quantity_from_spreader_quantity(const LegPropertyData& leg, Quantity spreader_order_quantity) + { + return leg.size_multiplier () * spreader_order_quantity.value(); + } + /**********************************************************************/ + /*******************************Orders*********************************/ + /**********************************************************************/ static bool order_acknowledged (api::orderman::OrderStatus order_status) { // any state but that means order is ack'ed return order_status!=api::orderman::OrderStatus::OS_UNACKNOWLEDGED; } - - static bool order_in_terminal_state(api::orderman::OrderStatus order_status) { return order_status == api::orderman::OrderStatus::OS_REJECTED_BY_SPARK || @@ -91,7 +112,10 @@ public: order_status == api::orderman::OrderStatus::OS_STOPPED || order_status == api::orderman::OrderStatus::OS_REJECTED || order_status == api::orderman::OrderStatus::OS_EXPIRED; - } + } + /**********************************************************************/ + /****************************Market Data*******************************/ + /**********************************************************************/ // CRITICAL PATH // this traverses the depth of the book, accumulating the quantity, // till the target quantity is reached. if the target quantity is not @@ -136,6 +160,9 @@ public: out_price = Price(book_depth[last_nonzero_level].price()); } } + /**********************************************************************/ + /****************************Quoting Params****************************/ + /**********************************************************************/ // given the new price, applies the quoting parameters (mute etc) // to see if quote needs to be repriced static bool reprice_quote_mute_zone(double current_price, double new_price, api::Side quote_side, double tick_size, @@ -167,5 +194,22 @@ public: else return false; } + /**********************************************************************/ + /**********************Quoting Pricing Calculation*********************/ + /**********************************************************************/ + // calculates the computed price and quantity for a quoting + // leg given the data for the other leg + static void compute_price_quantity_2_legs(const QuoteLegPriceQuantityState& this_leg_state, const LegPropertyData& this_leg_data, + const LegPropertyData& other_leg_data, const orderman::Book& other_leg_book, + Price& price, Quantity& quantity) + { + Price other_leg_calc_price; Quantity other_leg_calc_quantity; + Quantity this_leg_target_quantity = this_leg_state.remaining_to_fill(); + double other_leg_total_lean_ratio = other_leg_data.leg_params.quote_params().lean_quantity_ratio() * other_leg_data.size_multiplier() / this_leg_data.size_multiplier(); + double other_leg_target_quantity = this_leg_target_quantity.value() * other_leg_total_lean_ratio; + SpreaderUtils::traverse_depth_for_quantity(other_leg_book, SpreaderUtils::invert_side (other_leg_data.trading_side), Quantity(other_leg_target_quantity), other_leg_calc_price, other_leg_calc_quantity); + quantity = Quantity(static_cast(1.0 /*TODOit->lean_ratio*/ * other_leg_calc_quantity.value())); // TODO + price = Price((this_leg_state.target_spread_price().value() - other_leg_calc_price.value() * other_leg_data.price_multiplier())/this_leg_data.price_multiplier()); + } }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/IQuoterStateWorker.h b/src/server/sparkd/spreader/quoter/IQuoterStateWorker.h index 807da5728..9437bb443 100644 --- a/src/server/sparkd/spreader/quoter/IQuoterStateWorker.h +++ b/src/server/sparkd/spreader/quoter/IQuoterStateWorker.h @@ -14,6 +14,7 @@ class IQuoterStateWorker public: // state of this worker virtual QuoterState state () const = 0; + virtual const std::string& state_text () const = 0; // called once at the start before everything else virtual void build_once (SingleLegQuoter* quoter) = 0; // called once and only once, before any other calls. @@ -31,9 +32,8 @@ public: virtual void on_time(const TimeStamp&) = 0; // on a quoting fill on one of the other legs virtual void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) = 0; - // when user updates the spreader order price - virtual void update_spreader_order_price (Price new_price) = 0; - // when user updates the spreader order quantity - virtual void update_spreader_order_quantity (Quantity new_quantity) = 0; + // when a spreader order gets updated, it could be that the one of + // the price or quantity does not change + virtual void update_spreader_order (Price price, Quantity quantity) = 0; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp index 539532acb..71a621795 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp @@ -6,13 +6,15 @@ namespace bts{ namespace orderman{ -QuoterState QuoterEndStateWorker::state () const {return QuoterState::START;} +QuoterState QuoterEndStateWorker::state () const {return QuoterState::END;} void QuoterEndStateWorker::build_once (SingleLegQuoter* quoter) { _quoter = quoter; } void QuoterEndStateWorker::init () -{} +{ + bts_assert_msg (false, "QuoterEndStateWorker::init is an illegal operation"); +} void QuoterEndStateWorker::on_order_update (const SpreaderOrderUpdateMessage&) {} void QuoterEndStateWorker::on_book (bts::orderman::TickToTradeCorID, size_t, const bts::orderman::Book&) @@ -25,9 +27,6 @@ void QuoterEndStateWorker::on_time(const TimeStamp&) {} void QuoterEndStateWorker::other_leg_quoter_fill (size_t, Quantity) {} -void QuoterEndStateWorker::update_spreader_order_price (Price) +void QuoterEndStateWorker::update_spreader_order (Price, Quantity) {} -void QuoterEndStateWorker::update_spreader_order_quantity (Quantity) -{} - }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.h index 678550b55..4e3d7617d 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterEndStateWorker.h @@ -10,12 +10,18 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// this the final state. except for an assert +// on init, its a no-op class QuoterEndStateWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; +public: + QuoterEndStateWorker () : _state_text ("END") {} public: QuoterState state () const override; + const std::string& state_text () const override {return _state_text;} void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; @@ -24,7 +30,6 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp index 07df6c8a7..8edf2b56a 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp @@ -14,7 +14,6 @@ void QuoterStartStateWorker::build_once (SingleLegQuoter* quoter) } void QuoterStartStateWorker::init () { - LOG(OrderMan, Diag, "QuoterStartStateWorker::init key: {}", _quoter->_child_order.order_key().value()); _quoter->_transform_to_WAITING_FOR_SIZE(); } void QuoterStartStateWorker::on_order_update (const SpreaderOrderUpdateMessage&) @@ -31,38 +30,35 @@ void QuoterStartStateWorker::cancel() { // since no order has been sent for this leg, cancel just takes // it to the end state - LOG(OrderMan, Diag, "QuoterStartStateWorker::cancel key: {}, transforming to end", _quoter->_child_order.order_key().value()); _quoter->_transform_to_END (); } void QuoterStartStateWorker::terminate() { // termination is the same behaviour in any state - LOG(OrderMan, Diag, "QuoterStartStateWorker::terminate key: {}, transforming to end", _quoter->_child_order.order_key().value()); _quoter->_transform_to_END (); } void QuoterStartStateWorker::on_time(const TimeStamp&) {} void QuoterStartStateWorker::other_leg_quoter_fill (size_t leg_index, Quantity filled_quantity) { - LOG(OrderMan, Diag, "QuoterStartStateWorker::other_leg_quoter_fill key: {}, leg_index {} filled_quantity {}", - _quoter->_child_order.order_key().value(), leg_index, filled_quantity.value()); + // if the other leg has been filled the quoting size gets reduced. + // it can potentially get reduced all the way to 0, and since an + // order for this leg has not been sent out, it directly goes to END _quoter->_incorporate_other_leg_fill (leg_index, filled_quantity); - if (_quoter->_price_quantity_state.target_reached()) - { - LOG(OrderMan, Diag, "QuoterStartStateWorker::other_leg_quoter_fill key: {}, target reached, transforming to end", _quoter->_child_order.order_key().value()); - _quoter->_transform_to_END (); - } + _analyze_and_act (); } -void QuoterStartStateWorker::update_spreader_order_price (Price price) +void QuoterStartStateWorker::update_spreader_order (Price price, Quantity quantity) { - LOG(OrderMan, Diag, "QuoterStartStateWorker::update_spreader_order_price key: {}, price {}", _quoter->_child_order.order_key().value(), price.value()); - _quoter->_price_quantity_state.update_target_spread_price (price); + _quoter->_price_quantity_state.update_out_price_quantity (price, quantity); + _analyze_and_act (); } -void QuoterStartStateWorker::update_spreader_order_quantity (Quantity quantity) +void QuoterStartStateWorker::_analyze_and_act () { - LOG(OrderMan, Diag, "QuoterStartStateWorker::update_spreader_order_quantity key: {}, quantity {}", _quoter->_child_order.order_key().value(), quantity.value()); - Quantity this_leg_quantity = Quantity (_quoter->_get_equivelant_quantity_from_spreader_quantity (quantity)); - _quoter->_price_quantity_state.update_target_leg_quantity (this_leg_quantity); + if (_quoter->_price_quantity_state.target_reached()) + { + LOG(OrderMan, Diag, "QuoterStartStateWorker::other_leg_quoter_fill key: {}, target reached, transforming to end", _quoter->_order.order_key().value()); + _quoter->_transform_to_END (); + } } }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.h index 606d5973f..18cdfae19 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterStartStateWorker.h @@ -10,12 +10,17 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// this is the starting node of the state machine. +// this quickly goes to waiting_for_size on an init class QuoterStartStateWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; public: + QuoterStartStateWorker () : _state_text ("START") {} QuoterState state () const override; + const std::string& state_text () const override {return _state_text;} void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; @@ -24,7 +29,8 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; +private: + void _analyze_and_act (); }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp index 37f54d7a2..9bfa6db24 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.cpp @@ -2,32 +2,46 @@ #include "server/sparkd/orderman/md/Book.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterState.h" +#include "server/sparkd/spreader/SingleLegQuoter.h" +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" namespace bts{ namespace orderman{ -QuoterState QuoterWaitingForCancelAckFinalStateWorker::state () const {return QuoterState::START;} +QuoterState QuoterWaitingForCancelAckFinalStateWorker::state () const {return QuoterState::WAITING_FOR_CANCEL_ACK_FINAL;} void QuoterWaitingForCancelAckFinalStateWorker::build_once (SingleLegQuoter* quoter) { _quoter = quoter; } void QuoterWaitingForCancelAckFinalStateWorker::init () -{} -void QuoterWaitingForCancelAckFinalStateWorker::on_order_update (const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "QuoterWaitingForCancelAckFinalStateWorker::init is an illegal operation"); +} +void QuoterWaitingForCancelAckFinalStateWorker::on_order_update (const SpreaderOrderUpdateMessage& u) +{ + bts_assert (u.acknowledged()); + _quoter->_price_quantity_state.add_filled_quantity (u.last_update_filled_quantity()); + if (u.terminal_status()) + _quoter->_transform_to_END (); +} void QuoterWaitingForCancelAckFinalStateWorker::on_book (bts::orderman::TickToTradeCorID, size_t, const bts::orderman::Book&) {} void QuoterWaitingForCancelAckFinalStateWorker::cancel() {} void QuoterWaitingForCancelAckFinalStateWorker::terminate() -{} +{ + _quoter->_transform_to_END (); +} void QuoterWaitingForCancelAckFinalStateWorker::on_time(const TimeStamp&) -{} -void QuoterWaitingForCancelAckFinalStateWorker::other_leg_quoter_fill (size_t, Quantity) -{} -void QuoterWaitingForCancelAckFinalStateWorker::update_spreader_order_price (Price) -{} -void QuoterWaitingForCancelAckFinalStateWorker::update_spreader_order_quantity (Quantity) -{} - +{ + // TODO check threshold +} +void QuoterWaitingForCancelAckFinalStateWorker::other_leg_quoter_fill (size_t leg_index, Quantity filled_quantity) +{ + _quoter->_incorporate_other_leg_fill (leg_index, filled_quantity); +} +void QuoterWaitingForCancelAckFinalStateWorker::update_spreader_order (Price price, Quantity quantity) +{ + _quoter->_price_quantity_state.update_out_price_quantity (price, quantity); +} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.h index bb30c86fe..5b249724f 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckFinalStateWorker.h @@ -10,12 +10,18 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// this state is reached when the cancel has been sent +// and it is waiting for the cancelled ack class QuoterWaitingForCancelAckFinalStateWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; public: + QuoterWaitingForCancelAckFinalStateWorker () : _state_text ("WAITING_FOR_CANCEL_ACK_FINAL") {} +public: QuoterState state () const override; + const std::string& state_text () const override {return _state_text;} void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; @@ -24,7 +30,6 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp index fdeea41b7..079ba8ddb 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.cpp @@ -2,32 +2,61 @@ #include "server/sparkd/orderman/md/Book.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterState.h" +#include "server/sparkd/spreader/SingleLegQuoter.h" +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" namespace bts{ namespace orderman{ -QuoterState QuoterWaitingForCancelAckReturnStateWorker::state () const {return QuoterState::START;} +QuoterState QuoterWaitingForCancelAckReturnStateWorker::state () const {return QuoterState::WAITING_FOR_CANCEL_ACK_CONTINUE;} void QuoterWaitingForCancelAckReturnStateWorker::build_once (SingleLegQuoter* quoter) { _quoter = quoter; } void QuoterWaitingForCancelAckReturnStateWorker::init () -{} -void QuoterWaitingForCancelAckReturnStateWorker::on_order_update (const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "QuoterWaitingForCancelAckReturnStateWorker::init is an illegal operation"); +} +void QuoterWaitingForCancelAckReturnStateWorker::on_order_update (const SpreaderOrderUpdateMessage& u) +{ + bts_assert (u.acknowledged()); + _quoter->_price_quantity_state.add_filled_quantity (u.last_update_filled_quantity()); + if (u.terminal_status()) + { + // order is in terminal status, this is most likely a fill, + // though in any case there is no action to take + // TODO : get new order from spreader + _quoter->_transform_to_WAITING_FOR_SIZE (); + } + else + _analyze_and_act (); +} void QuoterWaitingForCancelAckReturnStateWorker::on_book (bts::orderman::TickToTradeCorID, size_t, const bts::orderman::Book&) {} void QuoterWaitingForCancelAckReturnStateWorker::cancel() -{} +{ + _quoter->_transform_to_WAITING_FOR_CANCEL_ACK_FINAL (); +} void QuoterWaitingForCancelAckReturnStateWorker::terminate() -{} +{ + _quoter->_transform_to_END (); +} void QuoterWaitingForCancelAckReturnStateWorker::on_time(const TimeStamp&) {} -void QuoterWaitingForCancelAckReturnStateWorker::other_leg_quoter_fill (size_t, Quantity) -{} -void QuoterWaitingForCancelAckReturnStateWorker::update_spreader_order_price (Price) -{} -void QuoterWaitingForCancelAckReturnStateWorker::update_spreader_order_quantity (Quantity) -{} +void QuoterWaitingForCancelAckReturnStateWorker::other_leg_quoter_fill (size_t leg_index, Quantity filled_quantity) +{ + _quoter->_incorporate_other_leg_fill (leg_index, filled_quantity); + _analyze_and_act (); +} +void QuoterWaitingForCancelAckReturnStateWorker::update_spreader_order (Price price, Quantity quantity) +{ + _quoter->_price_quantity_state.update_out_price_quantity (price, quantity); + _analyze_and_act (); +} +void QuoterWaitingForCancelAckReturnStateWorker::_analyze_and_act () +{ + if (_quoter->_price_quantity_state.target_reached()) + _quoter->_transform_to_WAITING_FOR_CANCEL_ACK_FINAL (); +} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.h index 1501ee3bb..db903bb5e 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForCancelAckReturnStateWorker.h @@ -10,12 +10,18 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// if the market dissapears from a working order and the target +// has not been reached, then working->waiting_for_cancel_ack_return +// happen. here it waits for the cancels and goes back to working_for_size class QuoterWaitingForCancelAckReturnStateWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; public: + QuoterWaitingForCancelAckReturnStateWorker () : _state_text ("WAITING_FOR_CANCEL_ACK_CONTINUE") {} QuoterState state () const override; + const std::string& state_text () const override {return _state_text;} void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; @@ -24,7 +30,8 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; +private: + void _analyze_and_act (); }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp index 4f9c6a370..03994c625 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp @@ -2,32 +2,50 @@ #include "server/sparkd/orderman/md/Book.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterState.h" +#include "server/sparkd/spreader/SingleLegQuoter.h" +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" namespace bts{ namespace orderman{ -QuoterState QuoterWaitingForFirstAckCancelledWorker::state () const {return QuoterState::START;} +QuoterState QuoterWaitingForFirstAckCancelledWorker::state () const {return QuoterState::WAITING_FOR_FIRST_ACK_CANCELLED;} void QuoterWaitingForFirstAckCancelledWorker::build_once (SingleLegQuoter* quoter) { _quoter = quoter; } void QuoterWaitingForFirstAckCancelledWorker::init () -{} -void QuoterWaitingForFirstAckCancelledWorker::on_order_update (const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "QuoterWaitingForFirstAckCancelledWorker::init is an illegal operation"); +} +void QuoterWaitingForFirstAckCancelledWorker::on_order_update (const SpreaderOrderUpdateMessage& u) +{ + bts_assert (u.acknowledged()); + _quoter->_price_quantity_state.add_filled_quantity (u.last_update_filled_quantity()); + if (u.terminal_status()) + _quoter->_transform_to_END (); + else + { + // got an ack, now cancel the order + _quoter->_order.cancel(); + _quoter->_transform_to_WAITING_FOR_CANCEL_ACK_FINAL (); + } +} void QuoterWaitingForFirstAckCancelledWorker::on_book (bts::orderman::TickToTradeCorID, size_t, const bts::orderman::Book&) {} void QuoterWaitingForFirstAckCancelledWorker::cancel() {} void QuoterWaitingForFirstAckCancelledWorker::terminate() -{} +{ + _quoter->_transform_to_END (); +} void QuoterWaitingForFirstAckCancelledWorker::on_time(const TimeStamp&) {} -void QuoterWaitingForFirstAckCancelledWorker::other_leg_quoter_fill (size_t, Quantity) -{} -void QuoterWaitingForFirstAckCancelledWorker::update_spreader_order_price (Price) -{} -void QuoterWaitingForFirstAckCancelledWorker::update_spreader_order_quantity (Quantity) -{} - +void QuoterWaitingForFirstAckCancelledWorker::other_leg_quoter_fill (size_t leg_index, Quantity filled_quantity) +{ + _quoter->_incorporate_other_leg_fill (leg_index, filled_quantity); +} +void QuoterWaitingForFirstAckCancelledWorker::update_spreader_order (Price price, Quantity quantity) +{ + _quoter->_price_quantity_state.update_out_price_quantity (price, quantity); +} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.h index 5ec9e415f..5fec5e2f0 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.h @@ -10,12 +10,19 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// this is the most improbable yet theoretically possible state +// of an order getting cancelled in waiting_for_first_ack. in that +// case it enters this state in which it waits for an ack and then +// cancels the order class QuoterWaitingForFirstAckCancelledWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; public: + QuoterWaitingForFirstAckCancelledWorker () : _state_text ("WAITING_FOR_FIRST_ACK_CANCELLED") {} QuoterState state () const override; + const std::string& state_text () const override {return _state_text;} void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; @@ -24,7 +31,6 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp index 9ac89d0b5..436e569bb 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp @@ -2,32 +2,56 @@ #include "server/sparkd/orderman/md/Book.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterState.h" +#include "server/sparkd/spreader/SingleLegQuoter.h" +#include "server/sparkd/spreader/SpreaderOrderUpdateMessage.h" namespace bts{ namespace orderman{ -QuoterState QuoterWaitingForFirstAckWorker::state () const {return QuoterState::START;} +QuoterState QuoterWaitingForFirstAckWorker::state () const {return QuoterState::WAITING_FOR_FIRST_ACK;} void QuoterWaitingForFirstAckWorker::build_once (SingleLegQuoter* quoter) { _quoter = quoter; } void QuoterWaitingForFirstAckWorker::init () -{} -void QuoterWaitingForFirstAckWorker::on_order_update (const SpreaderOrderUpdateMessage&) -{} +{ + bts_assert_msg (false, "QuoterWaitingForFirstAckWorker::init is an illegal operation"); +} +void QuoterWaitingForFirstAckWorker::on_order_update (const SpreaderOrderUpdateMessage& u) +{ + bts_assert (u.acknowledged()); + _quoter->_price_quantity_state.add_filled_quantity (u.last_update_filled_quantity()); + if (u.terminal_status()) + _quoter->_transform_to_END (); + else + _quoter->_transform_to_WORKING (); +} void QuoterWaitingForFirstAckWorker::on_book (bts::orderman::TickToTradeCorID, size_t, const bts::orderman::Book&) {} void QuoterWaitingForFirstAckWorker::cancel() -{} +{ + _quoter->_transform_to_WAITING_FOR_FIRST_ACK_CANCELLED (); +} void QuoterWaitingForFirstAckWorker::terminate() -{} +{ + _quoter->_transform_to_END (); +} void QuoterWaitingForFirstAckWorker::on_time(const TimeStamp&) {} -void QuoterWaitingForFirstAckWorker::other_leg_quoter_fill (size_t, Quantity) -{} -void QuoterWaitingForFirstAckWorker::update_spreader_order_price (Price) -{} -void QuoterWaitingForFirstAckWorker::update_spreader_order_quantity (Quantity) -{} +void QuoterWaitingForFirstAckWorker::other_leg_quoter_fill (size_t leg_index, Quantity filled_quantity) +{ + _quoter->_incorporate_other_leg_fill (leg_index, filled_quantity); + _analyze_and_act (); +} +void QuoterWaitingForFirstAckWorker::update_spreader_order (Price price, Quantity quantity) +{ + _quoter->_price_quantity_state.update_out_price_quantity (price, quantity); + _analyze_and_act (); +} +void QuoterWaitingForFirstAckWorker::_analyze_and_act () +{ + if (_quoter->_price_quantity_state.target_reached()) + _quoter->_transform_to_WAITING_FOR_FIRST_ACK_CANCELLED(); +} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.h index 46333f4bf..d047721b3 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.h @@ -10,12 +10,18 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// waiting_for_size transitions to waiting_for_first_ack on +// an order submission. here it waits for the first ack and +// goes to working (mostly) class QuoterWaitingForFirstAckWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; public: + QuoterWaitingForFirstAckWorker () : _state_text ("WAITING_FOR_FIRST_ACK") {} QuoterState state () const override; + const std::string& state_text () const override {return _state_text;} void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; @@ -24,7 +30,10 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; +private: + // checks if the target is reached, and cancels + // the order if so + void _analyze_and_act (); }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp index 1c1dd2995..98f0fc8e4 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp @@ -7,7 +7,7 @@ namespace bts{ namespace orderman{ -QuoterState QuoterWaitingForSizeStateWorker::state () const {return QuoterState::START;} +QuoterState QuoterWaitingForSizeStateWorker::state () const {return QuoterState::WAITING_FOR_SIZE;} void QuoterWaitingForSizeStateWorker::build_once (SingleLegQuoter* quoter) { _quoter = quoter; @@ -24,67 +24,49 @@ void QuoterWaitingForSizeStateWorker::on_order_update (const SpreaderOrderUpdate void QuoterWaitingForSizeStateWorker::on_book (bts::orderman::TickToTradeCorID corid, size_t, const bts::orderman::Book&) { Price out_price; Quantity out_quantity; - _compute_and_place_order (corid); + _longpath_analyze_and_act (corid); } void QuoterWaitingForSizeStateWorker::cancel() { // since no order has been sent for this leg, cancel just takes // it to the end state - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker::cancel key: {}, transforming to end", _quoter->_child_order.order_key().value()); _quoter->_transform_to_END (); } void QuoterWaitingForSizeStateWorker::terminate() { - // termination is the same behaviour in any state - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker::terminate key: {}, transforming to end", _quoter->_child_order.order_key().value()); _quoter->_transform_to_END (); } void QuoterWaitingForSizeStateWorker::on_time(const TimeStamp&) {} void QuoterWaitingForSizeStateWorker::other_leg_quoter_fill (size_t leg_index, Quantity filled_quantity) { - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker::other_leg_quoter_fill key: {}, leg_index {} filled_quantity {}", - _quoter->_child_order.order_key().value(), leg_index, filled_quantity.value()); _quoter->_incorporate_other_leg_fill (leg_index, filled_quantity); + _longpath_analyze_and_act (bts::orderman::NullTickToTradeCorID); +} +void QuoterWaitingForSizeStateWorker::update_spreader_order (Price price, Quantity quantity) +{ + _quoter->_price_quantity_state.update_out_price_quantity (price, quantity); + _longpath_analyze_and_act (bts::orderman::NullTickToTradeCorID); +} +void QuoterWaitingForSizeStateWorker::_longpath_analyze_and_act (bts::orderman::TickToTradeCorID corid) +{ if (_quoter->_price_quantity_state.target_reached()) { - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker::other_leg_quoter_fill key: {}, target reached, transforming to end", _quoter->_child_order.order_key().value()); + LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker key: {}, target reached, transforming to end", _quoter->_order.order_key().value()); _quoter->_transform_to_END (); } else - _compute_and_place_order (bts::orderman::NullTickToTradeCorID); -} -void QuoterWaitingForSizeStateWorker::update_spreader_order_price (Price price) -{ - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker::update_spreader_order_price key: {}, price {}", _quoter->_child_order.order_key().value(), price.value()); - _quoter->_price_quantity_state.update_target_spread_price (price); -} -void QuoterWaitingForSizeStateWorker::update_spreader_order_quantity (Quantity quantity) -{ - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker::update_spreader_order_quantity key: {}, quantity {}", _quoter->_child_order.order_key().value(), quantity.value()); - Quantity this_leg_quantity = Quantity (_quoter->_get_equivelant_quantity_from_spreader_quantity (quantity)); - _quoter->_price_quantity_state.update_target_leg_quantity (this_leg_quantity); - if (_quoter->_price_quantity_state.target_reached()) { - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker::other_leg_quoter_fill key: {}, target reached, transforming to end", _quoter->_child_order.order_key().value()); - _quoter->_transform_to_END (); - } - else - _compute_and_place_order (bts::orderman::NullTickToTradeCorID); -} - -void QuoterWaitingForSizeStateWorker::_compute_and_place_order (bts::orderman::TickToTradeCorID corid) -{ - Price out_price; Quantity out_quantity; - _quoter->_compute_price_quantity (out_price, out_quantity); - if (out_quantity.value() > 0) - { - _quoter->_price_quantity_state.update_out_price_quantity(out_price, out_quantity); - LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker key: {}, sending order, price: {} quantity: {}", - _quoter->_child_order.order_key().value(), out_price.value(), out_quantity.value()); - // This is the only place from where the order is sent - _quoter->_child_order.create(corid, _quoter->_price_quantity_state.out_price(), _quoter->_price_quantity_state.out_quantity()); - _quoter->_tranform_to_WAITING_FOR_FIRST_ACK (); + Price out_price; Quantity out_quantity; + _quoter->_compute_price_quantity (out_price, out_quantity); + if (out_quantity.value() > 0) + { + _quoter->_price_quantity_state.update_out_price_quantity(out_price, out_quantity); + LOG(OrderMan, Diag, "QuoterWaitingForSizeStateWorker key: {}, sending order, price: {} quantity: {}", + _quoter->_order.order_key().value(), out_price.value(), out_quantity.value()); + _quoter->_order.create(corid, _quoter->_price_quantity_state.out_price(), _quoter->_price_quantity_state.out_quantity()); + _quoter->_transform_to_WAITING_FOR_FIRST_ACK (); + } } } diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.h index 4bd0884b5..3fc1b8d50 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.h @@ -10,13 +10,19 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// start state transitions to waiting_for_size, on an init call. +// here the quoter waits until it can compute a valid price, quantity. +// once it can, it places the order and moves to waiting_for_first_ack class QuoterWaitingForSizeStateWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; public: + QuoterWaitingForSizeStateWorker () : _state_text ("WAITING_FOR_SIZE") {} QuoterState state () const override; - void build_once (SingleLegQuoter* quoter) override; + const std::string& state_text () const override {return _state_text;} + void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; void on_book (bts::orderman::TickToTradeCorID corid, size_t leg_id, const bts::orderman::Book& book) override; @@ -24,11 +30,11 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; private: - // computes the price and quantity of this leg, and - // and places an order if the size is available - void _compute_and_place_order (bts::orderman::TickToTradeCorID corid); + // checks to see if target has reached and goes to end + // if it has. otherwise computes the price, qty and if + // its valid, places an order goes to waiting_for_first_ack + void _longpath_analyze_and_act (bts::orderman::TickToTradeCorID corid); }; }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp index d6d4fe39e..3e69d904a 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp @@ -2,32 +2,101 @@ #include "server/sparkd/orderman/md/Book.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.h" #include "server/sparkd/spreader/quoter/quoter_states/QuoterState.h" +#include "server/sparkd/spreader/SingleLegQuoter.h" namespace bts{ namespace orderman{ -QuoterState QuoterWorkingStateWorker::state () const {return QuoterState::START;} +QuoterState QuoterWorkingStateWorker::state () const {return QuoterState::WORKING;} void QuoterWorkingStateWorker::build_once (SingleLegQuoter* quoter) { _quoter = quoter; } void QuoterWorkingStateWorker::init () -{} -void QuoterWorkingStateWorker::on_order_update (const SpreaderOrderUpdateMessage&) -{} -void QuoterWorkingStateWorker::on_book (bts::orderman::TickToTradeCorID, size_t, const bts::orderman::Book&) -{} +{ + bts_assert_msg (false, "QuoterWorkingStateWorker::init is an illegal operation"); +} +void QuoterWorkingStateWorker::on_order_update (const SpreaderOrderUpdateMessage& u) +{ + bts_assert (u.acknowledged()); + _quoter->_price_quantity_state.add_filled_quantity (u.last_update_filled_quantity()); + if (u.terminal_status()) + _quoter->_transform_to_END (); + else + _longpath_analyze_and_act (bts::orderman::NullTickToTradeCorID); +} +void QuoterWorkingStateWorker::on_book (bts::orderman::TickToTradeCorID corid, size_t, + const bts::orderman::Book&) +{ + _longpath_analyze_and_act (corid); +} void QuoterWorkingStateWorker::cancel() -{} +{ + _quoter->_order.cancel (); + _quoter->_transform_to_WAITING_FOR_CANCEL_ACK_FINAL (); +} void QuoterWorkingStateWorker::terminate() -{} +{ + _quoter->_transform_to_END (); +} void QuoterWorkingStateWorker::on_time(const TimeStamp&) {} -void QuoterWorkingStateWorker::other_leg_quoter_fill (size_t, Quantity) -{} -void QuoterWorkingStateWorker::update_spreader_order_price (Price) -{} -void QuoterWorkingStateWorker::update_spreader_order_quantity (Quantity) -{} +void QuoterWorkingStateWorker::other_leg_quoter_fill (size_t leg_index, Quantity filled_quantity) +{ + _quoter->_incorporate_other_leg_fill (leg_index, filled_quantity); + _longpath_analyze_and_act (bts::orderman::NullTickToTradeCorID); +} +void QuoterWorkingStateWorker::update_spreader_order (Price price, Quantity quantity) +{ + _quoter->_price_quantity_state.update_out_price_quantity (price, quantity); + _longpath_analyze_and_act (bts::orderman::NullTickToTradeCorID); +} +void QuoterWorkingStateWorker::_longpath_analyze_and_act (bts::orderman::TickToTradeCorID corid) +{ + if (_quoter->_price_quantity_state.target_reached()) + { + // this could happen if + // i. fills in this leg (though that should be caught by the status) + // ii. fills in other legs causing reduction here + // iii. quantity reduction in the spreader order by the user + _quoter->_order.cancel (); + _quoter->_transform_to_WAITING_FOR_CANCEL_ACK_FINAL (); + } + else + { + Price new_price; Quantity new_quantity; + _quoter->_compute_price_quantity (new_price, new_quantity); + //new_quantity = Quantity(new_quantity.value() + _quoter->_price_quantity_state.aggregated_filled_quantity().value()); + // TODO, some adjustment for fills needed + if (new_quantity.value() == 0) + { + // no size could be computed, go to wait state + _quoter->_order.cancel (); + _quoter->_transform_to_WAITING_FOR_CANCEL_ACK_CONTINUE (); + } + else + { + if (new_quantity.value() != _quoter->_price_quantity_state.out_quantity().value()) + { + // this is a size change, size changes always go through regardless of the + // quoting parameters + _quoter->_price_quantity_state.update_out_price_quantity(new_price, new_quantity); + _quoter->_order.update(corid, new_price, new_quantity); + } + else + { + bool reprice = true; + if (_quoter->_this_leg_data.leg_params.quote_params().has_quote_mute_zone()) + reprice = SpreaderUtils::reprice_quote_mute_zone(_quoter->_price_quantity_state.out_price().value(), new_price.value(), _quoter->_this_leg_data.trading_side, + _quoter->_this_leg_data.tick_size(), _quoter->_this_leg_data.leg_params.quote_params().quote_mute_zone()); + if (reprice) + { + _quoter->_price_quantity_state.update_out_price_quantity(new_price, new_quantity); + _quoter->_order.update(corid, new_price, new_quantity); + } + } + } + } +} }} \ No newline at end of file diff --git a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.h b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.h index 556d2264c..6c5abf576 100644 --- a/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.h +++ b/src/server/sparkd/spreader/quoter/quoter_states/QuoterWorkingStateWorker.h @@ -10,12 +10,17 @@ namespace orderman { class SpreaderOrderUpdateMessage; class Book; class SingleLegQuoter; +// this is steady state where most of the action happens. +// waiting_for_ack on an ack, transforms into this state. class QuoterWorkingStateWorker : public IQuoterStateWorker { private: SingleLegQuoter* _quoter; + const std::string _state_text; public: + QuoterWorkingStateWorker () : _state_text ("WORKING") {} QuoterState state () const override; + const std::string& state_text () const override {return _state_text;} void build_once (SingleLegQuoter* quoter) override; void init () override; void on_order_update (const SpreaderOrderUpdateMessage& order_update) override; @@ -24,7 +29,12 @@ public: void terminate() override; void on_time(const TimeStamp& ts) override; void other_leg_quoter_fill (size_t leg_id, Quantity fill_quantity) override; - void update_spreader_order_price (Price new_price) override; - void update_spreader_order_quantity (Quantity new_quantity) override; + void update_spreader_order (Price price, Quantity quantity) override; +private: + // this does the following in this order + // i. if target reached => cxl order and go to waiting_for_cancel_ack_final + // ii. if computed_qty = 0 => cxl order and go to waiting_for_cancel_ack_continue + // iii. if reprice (ie qty changed or price changed beyond the threshold) => requote + void _longpath_analyze_and_act (bts::orderman::TickToTradeCorID); }; }} \ No newline at end of file diff --git a/src/server/sparkd/user/AccountServiceServer.cpp b/src/server/sparkd/user/AccountServiceServer.cpp new file mode 100644 index 000000000..b2d1d2142 --- /dev/null +++ b/src/server/sparkd/user/AccountServiceServer.cpp @@ -0,0 +1,187 @@ +#include "AccountServiceServer.h" + +#include "server/sparkd/persistence/SqliteStore.h" +#include "lib/logging/logging.h" +#include "lib/api/services/UserService.pb.h" +#include "lib/api/services/UserService.client.pb.h" +#include "lib/api/services/AccountService.pb.h" +#include "lib/utils/PBUtils.h" + +#include +#include +#include +#include +#include + +namespace bts +{ +namespace account +{ + +auto const account_ns = "accounts"; + +struct AccountServiceServer::PImpl +{ + PImpl(bts::api::ServiceContext& context) : store(new persistence::SqliteStore(account_ns)), user_service(context.locate()) + {} + std::unique_ptr store; + api::user::UserService user_service; + + void fill_defaults() + { + auto acct = api::account::Account::default_instance(); + auto tag1 = "TAG1"; + acct.set_tag1(tag1); + acct.set_can_trade(true); + auto bal = acct.mutable_balance(); + bal->set_cash_position(1000000.0); + bal->set_leverage_factor(1.0); + acct.add_allowed_operators()->set_tag50("BTS"); + acct.add_allowed_operators()->set_tag50("BTS2"); + acct.add_allowed_operators()->set_tag50("BTS3"); + api::account::RiskLimit limit = api::account::RiskLimit::default_instance(); + limit.set_max_order_size(100); + limit.set_max_position_long(1000); + limit.set_max_position_short(1000); + limit.set_max_position_net(1000); + auto futures = acct.mutable_future_limits(); + futures->insert(google::protobuf::MapPair("ES", limit)); + futures->insert(google::protobuf::MapPair("GC", limit)); + auto spreads = acct.mutable_spread_limits(); + spreads->insert(google::protobuf::MapPair("ES", limit)); + spreads->insert(google::protobuf::MapPair("GC", limit)); + + store->insert(account_ns, tag1, utils::pb::to_string(acct)); + } + + template + void authenticate_token(const api::user::AuthToken& token, C cb) + { + api::user::AuthenticateTokenRequest req; + req.mutable_token()->CopyFrom(token); + user_service.authenticate_token(req, [=](bts::api::Result<::bts::api::user::AuthenticateTokenResponse> resp) + { + if(resp.success()) + cb(resp.result()->is_valid() && (resp.result()->user().user_type() == api::user::USERTYPE_ADMIN), resp.result()->reason()); + else + cb(false, resp.error_message()); + } ); + } +}; + +AccountServiceServer::AccountServiceServer (bts::api::ServiceContext& context) : AccountServiceBase(context), me (new PImpl(context)) +{ + LOG(User,Warn,"Starting account service"); + auto data = me->store->retrieve_all(); + if(data.size() == 0) + { + LOG(User,Warn,"Empty account database, filling with defaults"); + me->fill_defaults(); + } +} + +AccountServiceServer::~AccountServiceServer () {} + +void AccountServiceServer::get_accounts(const api::account::GetAccountsRequest&, + const std::function& reply) +{ + api::account::GetAccountsResponse resp; + auto all = me->store->retrieve_all()[account_ns]; + for (auto const &kvp : all) + { + api::account::Account account; + if(utils::pb::from_string(kvp.second, &account)) + resp.add_accounts()->CopyFrom(account); + else + LOG(Api,Error, "Could not read account {} from storage. This should be investigated", kvp.first); + } + reply(resp); +} + +void AccountServiceServer::add_or_update_account(const api::account::AddOrUpdateAccountRequest& req, + const std::function& reply) +{ + if(req.has_account() && req.account().tag1() != "") + { + me->authenticate_token(req.token(), [=](bool result, const std::string& reason) + { + api::account::AccountOperationResponse resp; + resp.set_is_valid(false); + if(result) + { + if(me->store->retrieve_one(account_ns, req.account().tag1()).first) + me->store->update(account_ns, req.account().tag1(), utils::pb::to_string(req.account())); + else + me->store->insert(account_ns, req.account().tag1(), utils::pb::to_string(req.account())); + resp.set_is_valid(true); + } + resp.set_reason(reason); + reply(resp); + }); + } + else + { + api::account::AccountOperationResponse resp; + resp.set_is_valid(false); + resp.set_reason("Invalid account or tag1"); + reply(resp); + } +} + +void AccountServiceServer::remove_account(const api::account::RemoveAccountRequest& req, + const std::function& reply) +{ + if(req.tag1() != "") + { + me->authenticate_token(req.token(), [=](bool result, const std::string& reason) + { + api::account::AccountOperationResponse resp; + resp.set_is_valid(false); + if(result) + { + std::set rm; + rm.insert(req.tag1()); + me->store->remove(account_ns, rm); + resp.set_is_valid(true); + } + resp.set_reason(reason); + reply(resp); + }); + } + else + { + api::account::AccountOperationResponse resp; + resp.set_is_valid(false); + resp.set_reason("Invalid account or tag1"); + reply(resp); + } +} + +void AccountServiceServer::update_account_balance(const api::account::UpdateAccountBalanceRequest& req, + const std::function& reply) +{ + api::account::AccountOperationResponse resp; + resp.set_is_valid(false); + std::string reason; + if(req.tag1() != "" && req.has_new_balance() + /*&& me->authenticate_token(req.token(), &reason)*/) + { + auto existing = me->store->retrieve_one(account_ns, req.tag1()); + if(existing.first) + { + api::account::Account account; + if(utils::pb::from_string(existing.second, &account)) + { + account.mutable_balance()->CopyFrom(req.new_balance()); + me->store->update(account_ns, account.tag1(), utils::pb::to_string(account)); + resp.set_is_valid(true); + } + } + } + resp.set_reason(reason); + reply(resp); +} + + +} +} diff --git a/src/server/sparkd/user/AccountServiceServer.h b/src/server/sparkd/user/AccountServiceServer.h new file mode 100644 index 000000000..490b48cb2 --- /dev/null +++ b/src/server/sparkd/user/AccountServiceServer.h @@ -0,0 +1,35 @@ +#pragma once + +#include +#include "lib/api/services/AccountService.server.pb.h" +#include "lib/utils/bts_no_copy.h" + +namespace bts +{ +namespace account +{ +class AccountServiceServer : public api::account::AccountServiceBase +{ +public: + BTS_NO_COPY(AccountServiceServer); + AccountServiceServer(bts::api::ServiceContext& context); + ~AccountServiceServer(); + + void get_accounts(const api::account::GetAccountsRequest&, + const std::function&) override; + + void add_or_update_account(const api::account::AddOrUpdateAccountRequest&, + const std::function&) override; + + void remove_account(const api::account::RemoveAccountRequest&, + const std::function&) override; + + void update_account_balance(const api::account::UpdateAccountBalanceRequest&, + const std::function&) override; + +private: + struct PImpl; + std::unique_ptr me; +}; +} +} diff --git a/src/server/sparkd/user/UserServiceServer.cpp b/src/server/sparkd/user/UserServiceServer.cpp index 9b79607ea..a8aef119c 100644 --- a/src/server/sparkd/user/UserServiceServer.cpp +++ b/src/server/sparkd/user/UserServiceServer.cpp @@ -1,42 +1,242 @@ #include "UserServiceServer.h" + +#include "server/sparkd/persistence/SqliteStore.h" #include "lib/logging/logging.h" -#include "lib/config/config.h" -#include "lib/config/protos/User.pb.h" +#include "lib/api/services/UserService.pb.h" +#include "lib/utils/PBUtils.h" -namespace bts { -namespace user { +#include +#include +#include +#include -UserServiceServer::UserServiceServer (bts::api::ServiceContext& context) : UserServiceBase(context) +namespace bts { - LOG(User,Warn,"Starting user service"); +namespace user +{ + +auto const user_ns = "users"; +auto const auth_salt = "blue-trading-systems-llc"; //_ is a token +const std::string auth_key = "BT5p@rk"; + +struct UserServiceServer::PImpl +{ + PImpl() : store(new persistence::SqliteStore(user_ns)) + {} + std::unique_ptr store; + + void fill_defaults() + { + { + auto user = api::user::User::default_instance(); + auto login = "bts"; + user.set_login(login); + user.set_password(""); + store->insert(user_ns, login, utils::pb::to_string(user)); + } + { + auto user = api::user::User::default_instance(); + auto login = "bts2"; + user.set_login(login); + user.set_password("bts2"); + auto oper = user.add_operators(); + oper->set_can_trade(true); + auto oid1 = oper->mutable_operator_id(); + oid1->set_tag50("BTS2"); + store->insert(user_ns, login, utils::pb::to_string(user)); + } + { + auto user = api::user::User::default_instance(); + auto login = "bts3"; + user.set_login(login); + user.set_password("bts3"); + auto oper = user.add_operators(); + oper->set_can_trade(true); + auto oid1 = oper->mutable_operator_id(); + oid1->set_tag50("BTS3"); + + oper = user.add_operators(); + oper->set_can_trade(false); + auto oid2 = oper->mutable_operator_id(); + oid2->set_tag50("BTS3_"); + store->insert(user_ns, login, utils::pb::to_string(user)); + } + { + auto user = api::user::User::default_instance(); + auto login = "btsadmin"; + user.set_login(login); + user.set_password("BT5u53r"); + user.set_user_type(api::user::USERTYPE_ADMIN); + store->insert(user_ns, login, utils::pb::to_string(user)); + } + } + + void xor_crypt(const std::string& key, std::string& data) + { + for(size_t i = 0; i != data.size(); i++) + data[i] ^= key[ i % key.size() ]; + } + + std::string generate_auth_token(const api::user::User& user) + { + //TODO -- expiration date? + std::string token = fmt::format("{}_{}_{}_{}", auth_salt, user.login(), user.password(), auth_salt); + xor_crypt(auth_key, token); + return token; + } + + void decode_auth_token(const api::user::AuthToken& token, std::string& user, std::string& pass) + { + std::string token_string = token.token(); + xor_crypt(auth_key, token_string); + using namespace boost; + char_separator sep("_"); + tokenizer> tokens(token_string, sep); + int i = 0; + for(const auto& t : tokens) + { + if(i == 1) + user = t; + else if(i == 2) + pass = t; + i++; + } + } + + bool authenticate_login(const std::string& login, const std::string& password, + api::user::User* user = nullptr, std::string* reason = nullptr) + { + std::pair val = store->retrieve_one(user_ns, login); + if(val.first) + { + api::user::User usr; + utils::pb::from_string(val.second, &usr); + if(password == usr.password() && login == usr.login()) + { + if(user) + *user = usr; + return true; + } + else if(reason) + *reason = "Bad user/password"; + } + else if(reason) + *reason = "User not found"; + return false; + } + + bool authenticate_token(const api::user::AuthToken& token, api::user::User* user = nullptr, std::string* reason = nullptr) + { + std::string login, pass; + decode_auth_token(token, login, pass); + return authenticate_login(login, pass, user, reason); + } +}; + +UserServiceServer::UserServiceServer (bts::api::ServiceContext& context) : UserServiceBase(context), me (new PImpl()) +{ + LOG(User,Warn,"Starting user service"); + auto data = me->store->retrieve_all(); + if(data.size() == 0) + { + LOG(User,Warn,"Empty user database, filling with defaults"); + me->fill_defaults(); + } } UserServiceServer::~UserServiceServer () {} -void UserServiceServer::get_logins(const api::user::GetLoginsRequest& , - const std::function& r ) +void UserServiceServer::get_users(const api::user::GetUsersRequest& , + const std::function& r ) { - api::user::GetLoginsRespose resp; - auto users = config::get(); - for (auto const &u : users.user()) - *resp.add_login() = u.login(); + api::user::GetUsersResponse resp; + auto all = me->store->retrieve_all()[user_ns]; + for (auto const &kvp : all) + { + api::user::User user; + if (utils::pb::from_string (kvp.second,&user)) + resp.add_users()->CopyFrom(user); + else + LOG(Api,Error, "Could not read user {} from storage. This should be investigated", kvp.first); + } r(resp); } -void UserServiceServer::authenticate_login(const api::user::AuthenticateLoginRequest& r, +void UserServiceServer::authenticate_login(const api::user::AuthenticateLoginRequest& req, const std::function& respond) { api::user::AuthenticateLoginResponse resp; - resp.set_is_valid(false); + resp.set_is_valid(false); - auto users = config::get(); - for (auto const &u : users.user()) - if (u.login() == r.login() && - u.password() == r.password()) { - resp.set_is_valid(true); - break; - } + api::user::User user; std::string reason; + resp.set_is_valid(me->authenticate_login(req.login(), req.password(), &user, &reason)); + resp.set_reason(reason); + if(resp.is_valid()) + { + auto toke = resp.mutable_token(); + toke->set_token(me->generate_auth_token(user)); + } respond(resp); } -}} +void UserServiceServer::authenticate_token(const api::user::AuthenticateTokenRequest& req, + const std::function& respond) +{ + api::user::AuthenticateTokenResponse resp; + api::user::User user; std::string reason; + resp.set_is_valid(me->authenticate_token(req.token(), &user, &reason)); + resp.set_reason(reason); + resp.mutable_user()->CopyFrom(user); + respond(resp); +} + +void UserServiceServer::add_or_update_user(const api::user::AddOrUpdateUserRequest& req, + const std::function& respond) +{ + api::user::UserOperationResponse resp; + resp.set_is_valid(false); + api::user::User user; std::string reason; + if(req.has_user() && req.user().login() != "" && + req.has_token() && me->authenticate_token(req.token(), &user, &reason)) + { + if(user.user_type() == api::user::USERTYPE_ADMIN) + { + if(me->store->retrieve_one(user_ns, req.user().login()).first) + me->store->update(user_ns, req.user().login(), utils::pb::to_string(req.user())); + else + me->store->insert(user_ns, req.user().login(), utils::pb::to_string(req.user())); + resp.set_is_valid(true); + } + else + resp.set_reason("Only admin users can add or update other users"); + } + else + resp.set_reason(reason); + respond(resp); +} + +void UserServiceServer::remove_user(const api::user::RemoveUserRequest& req, + const std::function& respond) +{ + api::user::UserOperationResponse resp; + resp.set_is_valid(false); + api::user::User user; std::string reason; + if(req.has_token() && me->authenticate_token(req.token(), &user, &reason)) + { + if(user.user_type() == api::user::USERTYPE_ADMIN) + { + std::set rm; + rm.insert(req.login()); + me->store->remove(user_ns, rm); + resp.set_is_valid(true); + } + else + resp.set_reason("Only admin users can remove other users"); + } + else + resp.set_reason(reason); + respond(resp); +} + +} +} diff --git a/src/server/sparkd/user/UserServiceServer.h b/src/server/sparkd/user/UserServiceServer.h index 34efffd26..586cedcb8 100644 --- a/src/server/sparkd/user/UserServiceServer.h +++ b/src/server/sparkd/user/UserServiceServer.h @@ -2,19 +2,33 @@ #include #include "lib/api/services/UserService.server.pb.h" +#include "lib/utils/bts_no_copy.h" -namespace bts { -namespace user { - +namespace bts +{ +namespace user +{ class UserServiceServer : public api::user::UserServiceBase { public: + BTS_NO_COPY(UserServiceServer); UserServiceServer (bts::api::ServiceContext& context); ~UserServiceServer(); - void get_logins(const api::user::GetLoginsRequest& , - const std::function& ) override; + void get_users(const api::user::GetUsersRequest& , + const std::function& ) override; void authenticate_login(const api::user::AuthenticateLoginRequest& , const std::function& ) override; + void authenticate_token(const api::user::AuthenticateTokenRequest& , + const std::function& ) override; + + void add_or_update_user(const api::user::AddOrUpdateUserRequest&, + const std::function& ) override; + void remove_user(const api::user::RemoveUserRequest&, + const std::function& ) override; + +private: + struct PImpl; + std::unique_ptr me; }; - -}} +} +} diff --git a/src/server/sparkd/user/tests/UserAndAccountTests.cpp b/src/server/sparkd/user/tests/UserAndAccountTests.cpp new file mode 100644 index 000000000..b9d5658a1 --- /dev/null +++ b/src/server/sparkd/user/tests/UserAndAccountTests.cpp @@ -0,0 +1,275 @@ +#include "catch/catch.hpp" + +#include "server/sparkd/user/UserServiceServer.h" +#include "server/sparkd/user/AccountServiceServer.h" + +#include "lib/api/public/ServiceContext.h" +#include "lib/api/services/AccountService.client.pb.h" +#include "lib/api/services/UserService.client.pb.h" +#include "lib/domain_model/Security.pb.h" +#include "lib/utils/helper_macros.h" +#include "lib/config/config.h" + +#include +#include + +using namespace bts::api::account; +using namespace bts::api::user; + +namespace bts +{ +namespace user +{ + +TEST_CASE ("UserService Service API", "[user]") +{ + using namespace api; + using namespace api::user; + + ServiceContext ctx; + bts::user::UserServiceServer srv(ctx); + auto _user = ctx.locate(); + + SECTION("get_users") + { + GetUsersRequest req; + auto resp = _user.get_users(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->users_size() > 0); + } + + SECTION("authenticate_login") + { + AuthenticateLoginRequest req; + req.set_login("bts"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + REQUIRE(resp.result()->token().token() != ""); + } + + SECTION("authenticate_token") + { + AuthenticateLoginRequest req; + req.set_login("bts2"); + req.set_password("bts2"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + const auto& toke = resp.result()->token(); + + AuthenticateTokenRequest req2; + req2.mutable_token()->CopyFrom(toke); + auto resp2 = _user.authenticate_token(req2); + REQUIRE(resp2.success()); + REQUIRE(resp2.result()->is_valid()); + } + + SECTION("add_or_update") + { + AuthenticateLoginRequest req; + req.set_login("btsadmin"); + req.set_password("BT5u53r"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + const auto& toke = resp.result()->token(); + + AddOrUpdateUserRequest r; + r.mutable_token()->CopyFrom(toke); + auto nu = r.mutable_user(); + nu->set_login("BTS_TEST123"); + nu->set_password("p@ssw0rd"); + + auto resp2 = _user.add_or_update_user(r); + REQUIRE(resp2.success()); + REQUIRE(resp2.result()->is_valid()); + } + + SECTION("remove") + { + AuthenticateLoginRequest req; + req.set_login("btsadmin"); + req.set_password("BT5u53r"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + const auto& toke = resp.result()->token(); + + RemoveUserRequest r; + r.mutable_token()->CopyFrom(toke); + r.set_login("BTS_TEST123"); + + auto resp2 = _user.remove_user(r); + REQUIRE(resp2.success()); + REQUIRE(resp2.result()->is_valid()); + } + + SECTION("add_or_update_fail") + { + AuthenticateLoginRequest req; + req.set_login("bts"); + req.set_password(""); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + const auto& toke = resp.result()->token(); + + AddOrUpdateUserRequest r; + r.mutable_token()->CopyFrom(toke); + auto nu = r.mutable_user(); + nu->set_login("111BTS_TEST123"); + nu->set_password("p@ssw0rd"); + + auto resp2 = _user.add_or_update_user(r); + REQUIRE(resp2.success()); + REQUIRE(!resp2.result()->is_valid()); + } + + SECTION("remove_fail") + { + AuthenticateLoginRequest req; + req.set_login("bts2"); + req.set_password("bts2"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + const auto& toke = resp.result()->token(); + + RemoveUserRequest r; + r.mutable_token()->CopyFrom(toke); + r.set_login("BTS_TEST123"); + + auto resp2 = _user.remove_user(r); + REQUIRE(resp2.success()); + REQUIRE(!resp2.result()->is_valid()); + } +} + +TEST_CASE ("AccountService Service API", "[account]") +{ + using namespace api; + using namespace api::account; + + ServiceContext ctx; + bts::user::UserServiceServer usrv(ctx); + auto _user = ctx.locate(); + + bts::account::AccountServiceServer asrv(ctx); + auto _account = ctx.locate(); + + SECTION("get_accounts") + { + GetAccountsRequest req; + auto resp = _account.get_accounts(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->accounts_size() > 0); + } + + SECTION("add_or_update_account") + { + AuthenticateLoginRequest req; + req.set_login("btsadmin"); + req.set_password("BT5u53r"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + const auto& toke = resp.result()->token(); + + AddOrUpdateAccountRequest r; + r.mutable_token()->CopyFrom(toke); + auto nu = r.mutable_account(); + nu->set_can_trade(true); + nu->set_tag1("TAG1!"); + nu->mutable_balance()->set_cash_position(100); + api::account::RiskLimit limit = api::account::RiskLimit::default_instance(); + limit.set_max_order_size(100); + limit.set_max_position_long(1000); + limit.set_max_position_short(1000); + limit.set_max_position_net(1000); + auto futures = nu->mutable_future_limits(); + futures->insert(google::protobuf::MapPair("ES", limit)); + futures->insert(google::protobuf::MapPair("GC", limit)); + auto spreads = nu->mutable_spread_limits(); + spreads->insert(google::protobuf::MapPair("ES", limit)); + spreads->insert(google::protobuf::MapPair("GC", limit)); + + auto resp2 = _account.add_or_update_account(r); + REQUIRE(resp2.success()); + REQUIRE(resp2.result()->is_valid()); + } + + SECTION("remove_account") + { + AuthenticateLoginRequest req; + req.set_login("btsadmin"); + req.set_password("BT5u53r"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + const auto& toke = resp.result()->token(); + + RemoveAccountRequest r; + r.mutable_token()->CopyFrom(toke); + r.set_tag1("TAG1!"); + + auto resp2 = _account.remove_account(r); + REQUIRE(resp2.success()); + REQUIRE(resp2.result()->is_valid()); + } + + SECTION("add_or_update_account_fail") + { + AuthenticateLoginRequest req; + req.set_login("bts"); + req.set_password(""); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + const auto& toke = resp.result()->token(); + + AddOrUpdateAccountRequest r; + r.mutable_token()->CopyFrom(toke); + auto nu = r.mutable_account(); + nu->set_can_trade(true); + nu->set_tag1("TAG1!"); + nu->mutable_balance()->set_cash_position(100); + api::account::RiskLimit limit = api::account::RiskLimit::default_instance(); + limit.set_max_order_size(100); + limit.set_max_position_long(1000); + limit.set_max_position_short(1000); + limit.set_max_position_net(1000); + auto futures = nu->mutable_future_limits(); + futures->insert(google::protobuf::MapPair("ES", limit)); + futures->insert(google::protobuf::MapPair("GC", limit)); + auto spreads = nu->mutable_spread_limits(); + spreads->insert(google::protobuf::MapPair("ES", limit)); + spreads->insert(google::protobuf::MapPair("GC", limit)); + + auto resp2 = _account.add_or_update_account(r); + REQUIRE(resp2.success()); + REQUIRE(!resp2.result()->is_valid()); + } + + SECTION("remove_account_fail") + { + AuthenticateLoginRequest req; + req.set_login("bts2"); + req.set_password("bts2"); + auto resp = _user.authenticate_login(req); + REQUIRE(resp.success()); + REQUIRE(resp.result()->is_valid()); + const auto& toke = resp.result()->token(); + + RemoveAccountRequest r; + r.mutable_token()->CopyFrom(toke); + r.set_tag1("TAG1!"); + + auto resp2 = _account.remove_account(r); + REQUIRE(resp2.success()); + REQUIRE(!resp2.result()->is_valid()); + } +} + + +}} + + diff --git a/tools/buildsparkd.cmd b/tools/buildsparkd.cmd index ab295fa1c..018ce6adb 100644 --- a/tools/buildsparkd.cmd +++ b/tools/buildsparkd.cmd @@ -1,4 +1,6 @@ @echo off +@setlocal +if "%SPARKVM_PORT%"=="" set SPARKVM_PORT=22 python %~dp0\replicator\replicate_to_linux_vm.py echo. -ssh bts@sparkvm -p 22 "cd /home/bts/spark/build/ninja_debug/ && ninja" +ssh bts@sparkvm -p %SPARKVM_PORT% -o StrictHostKeyChecking=no "cd /home/bts/spark/build/ninja_debug/ && ninja" diff --git a/tools/replicator/replicate_to_linux_vm.py b/tools/replicator/replicate_to_linux_vm.py index 44bb2f380..a2667bd67 100644 --- a/tools/replicator/replicate_to_linux_vm.py +++ b/tools/replicator/replicate_to_linux_vm.py @@ -4,7 +4,7 @@ import os, sys, subprocess, time spark_profile = \ '''\ root = $SOURCE -root = socket://sparkvm:8080/$TARGET +root = socket://sparkvm:$PORT/$TARGET ignore = Path build ignore = Path .git ignore = Path externals @@ -29,6 +29,8 @@ repo_name = os.path.basename(repo_root) profile_loc = os.path.join(os.path.abspath(os.environ['USERPROFILE']),'.unison') spark_profile = spark_profile.replace("$SOURCE", repo_root) spark_profile = spark_profile.replace("$TARGET", repo_name) +spark_profile = spark_profile.replace("$PORT", os.getenv("SPARKVM_UNISON_PORT", "8080")) + unison_exe = os.path.join(repo_root,"externals","windows","bin","unison.exe") diff --git a/tools/runsparkd.cmd b/tools/runsparkd.cmd index 16e8bd050..7ddb0b03f 100644 --- a/tools/runsparkd.cmd +++ b/tools/runsparkd.cmd @@ -1 +1,2 @@ -@ssh bts@sparkvm -p 22 "cd /home/bts/spark/build/ninja_debug/src/server/sparkd/ && ./sparkd %*" +@if "%SPARKVM_PORT%"=="" set SPARKVM_PORT=22 +@ssh bts@sparkvm -p %SPARKVM_PORT% "cd /home/bts/spark/build/ninja_debug/src/server/sparkd/ && ./sparkd %*" diff --git a/tools/vscode.cmd b/tools/vscode.cmd new file mode 100644 index 000000000..58b8ec076 --- /dev/null +++ b/tools/vscode.cmd @@ -0,0 +1,6 @@ +@echo off +setlocal +cd %~dp0\.. +call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\Common7\Tools\VsDevCmd.bat" > nul +cd %~dp0\.. +cmd /C start "" "C:\Program Files\Microsoft VS Code\Code.exe" From 377695716d4e792f3327eae4ba0e44924e4cca8e Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 13 Nov 2017 09:25:48 -0500 Subject: [PATCH 20/29] Updated docker --- docker/linux | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docker/linux b/docker/linux index d4a32d325..41523ccab 160000 --- a/docker/linux +++ b/docker/linux @@ -1 +1 @@ -Subproject commit d4a32d32592c688c3a1f042750fd3323bcdfd38a +Subproject commit 41523ccab74b95bb007d9b9330d52c0f9e12dd1e From 501f3ff4f28e195e91ce1ba93cbe16a06d91e07b Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 13 Nov 2017 09:26:16 -0500 Subject: [PATCH 21/29] Docker linux again --- docker/linux | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docker/linux b/docker/linux index d4a32d325..41523ccab 160000 --- a/docker/linux +++ b/docker/linux @@ -1 +1 @@ -Subproject commit d4a32d32592c688c3a1f042750fd3323bcdfd38a +Subproject commit 41523ccab74b95bb007d9b9330d52c0f9e12dd1e From 7f7fec6ae277de27345a1a947efc6e6da43d1e9a Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Mon, 13 Nov 2017 09:36:09 -0500 Subject: [PATCH 22/29] Fixed build. --- src/server/sparkd/cmds/Benchmark.cpp | 22 ---------------------- 1 file changed, 22 deletions(-) diff --git a/src/server/sparkd/cmds/Benchmark.cpp b/src/server/sparkd/cmds/Benchmark.cpp index c28ce390a..5624f5515 100644 --- a/src/server/sparkd/cmds/Benchmark.cpp +++ b/src/server/sparkd/cmds/Benchmark.cpp @@ -162,28 +162,6 @@ static void gen_id(benchmark::State &state) { } BENCHMARK(gen_id); -static void copy_native_order_proto_update(benchmark::State &state) { - api::orderman::OrderProtoUpdate master_update; - auto &update = *master_update.mutable_native(); - update.set_price (2500.1); - update.set_quantity(12); - update.set_last_price(2500); - update.set_avg_price(2500); - update.set_filled_quantity(0); - update.set_status(api::orderman::OS_UNACKNOWLEDGED); - update.set_order_id("123154232134234"); - update.set_reject_msg("123154232134234"); - - api::orderman::OrderProtoUpdate cpy(master_update); - - for (auto _ : state) { - master_update.mutable_native()->set_quantity(3); - *cpy.mutable_native() = master_update.native(); - benchmark::DoNotOptimize(cpy.native().quantity() == 3); - } -} -BENCHMARK(copy_native_order_proto_update); - static void mutex_lock_unlock(benchmark::State &state) { int i = 0; std::mutex lock; From 94a738129e7f868759d73065cdc3e1101d982862 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Mon, 13 Nov 2017 10:07:16 -0500 Subject: [PATCH 23/29] Make SecuritySource an instance isntead of static singleton --- .../spark/mspark/MarketView/MarketViewVM.cs | 6 ++-- .../SecurityBrowser/SecurityBrowserVM.cs | 2 +- .../SecuritySelectorDialogVM.cs | 2 +- .../SecurityBrowser/SecuritySelectorVM.cs | 4 +-- .../mspark/SecurityBrowser/SecuritySource.cs | 30 ++++++------------- .../spark/mspark/Shell/Fills/FillsVM.cs | 4 +-- .../Shell/LaunchMenu/LaunchMenuItemVM.cs | 27 +++++++++-------- .../mspark/Shell/LaunchMenu/LaunchMenuVM.cs | 4 +-- src/client/spark/mspark/Shell/MarketModule.cs | 9 ++++-- .../ModifySecuritySelectionMenuItem.cs | 6 ++-- .../Shell/TimeAndSales/TimeAndSalesVM.cs | 6 ++-- .../Shell/TimeAndSales/TimeAndSalesWindow.cs | 10 ++++--- src/client/spark/mspark/Shell/TradesModule.cs | 11 ++++--- 13 files changed, 63 insertions(+), 58 deletions(-) diff --git a/src/client/spark/mspark/MarketView/MarketViewVM.cs b/src/client/spark/mspark/MarketView/MarketViewVM.cs index 96560bcfd..a79bf3823 100644 --- a/src/client/spark/mspark/MarketView/MarketViewVM.cs +++ b/src/client/spark/mspark/MarketView/MarketViewVM.cs @@ -26,8 +26,9 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "MarketView"; - public MarketViewVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + public MarketViewVM(IBus bus, SecuritySource ssrc, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { _bus = bus; + _ssrc = ssrc; _resources.Add(_model = new MarketViewModel(bus)); _resources.Add(_rows = new RXObservableCollection(_model.rows)); _rows_vm = new ObservableAutoWrapper(_rows, smd => new Row(this, _model, smd, _model.security_position(smd.security.Id))); @@ -46,6 +47,7 @@ namespace mbts.spark } private readonly IBus _bus; + private readonly SecuritySource _ssrc; private readonly MarketViewModel _model; private readonly ContextMenuVM _context_menu; private readonly ObservableAutoWrapper _rows_vm; @@ -60,7 +62,7 @@ namespace mbts.spark } private IEnumerable _context_menu_item_factory() { - yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(_rows.Select(r => r.security).ToList(), _model.set_securities)); + yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(_rows.Select(r => r.security).ToList(), _ssrc, _model.set_securities)); if (current_cell != null && current_cell.Column != null && current_cell.Item != null && !current_cell.Item.Equals(System.Windows.DependencyProperty.UnsetValue)) { var curr_col = (Columns)DataGridEx.GetArgument(current_cell.Column); var securities = _rows_vm.Where(r => r.is_selected).Select(r => r.security.value).ToList(); diff --git a/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs b/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs index f623bf85c..a451b60ec 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs @@ -6,7 +6,7 @@ namespace mbts.spark { internal class SecurityBrowserVM : SecuritySelectorVM { - public SecurityBrowserVM(IBus bus) { + public SecurityBrowserVM(IBus bus, SecuritySource ssrc) :base(ssrc) { var orders_model = new OrdersModel(bus); _actions = MenuItemVM.CreateMenu(selected_securities, new CancelOrdersMenuItem(orders_model), new SyntheticCreateMenuItem(bus), new SyntheticStrategyMenuItem(bus), new OrderTicketMenuItem(orders_model)); _windows = MenuItemVM.CreateMenu(selected_securities, new LadderMenuItem(bus), new MarketViewMenuItem(bus), new SpreadMatrixMenuItem(bus), new TimeAndSalesMenuItem(bus)); diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs index bafe55598..1001a9038 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorDialogVM.cs @@ -8,7 +8,7 @@ namespace mbts.spark { internal class SecuritySelectorDialogVM : SecuritySelectorVM { - public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit) : this (title, preselected_securities, commit, SecuritySource.GetObservable()) { } + public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit, SecuritySource ssrc) : this (title, preselected_securities, commit, ssrc.GetObservable()) { } public SecuritySelectorDialogVM(string title, IReadOnlyCollection preselected_securities, Action> commit, IObservable securities_stream) : base(preselected_securities, securities_stream) { this.title = title; this.commit = new DelegateCommand(() => commit(selected_securities)); diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs index 9e7f04566..d9b174a2c 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySelectorVM.cs @@ -9,8 +9,8 @@ namespace mbts.spark { class SecuritySelectorVM : IDisposable { - public SecuritySelectorVM() : this(new SecurityImmutable[0]) { } - public SecuritySelectorVM(IReadOnlyCollection preselected_securities) : this(preselected_securities, SecuritySource.GetObservable()) { } + public SecuritySelectorVM(SecuritySource src) : this(new SecurityImmutable[0], src) { } + public SecuritySelectorVM(IReadOnlyCollection preselected_securities, SecuritySource src) : this(preselected_securities, src.GetObservable()) { } public SecuritySelectorVM(IReadOnlyCollection preselected_securities, IObservable securities_stream) { selected_securities = new ObservableCollection(preselected_securities); securities = new RXObservableCollection(securities_stream, SynchronizationContext.Current, TimeSpan.FromSeconds(1)); diff --git a/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs b/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs index ea162f69e..629b9ba5c 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecuritySource.cs @@ -9,29 +9,17 @@ using System.Reactive.Linq; namespace mbts.spark { - internal static class SecuritySource + [Export] + internal class SecuritySource { - public static IObservable GetObservable() { - return _instance.publisher.AsObservable(); + [ImportingConstructor] + public SecuritySource(IBus bus) { + securities = + bus.subscribe(SparkTags.SecuritiesTag).Select(dict => dict.Values.Select(s => s.security).ToArray()).Publish().RefCount(); } - - // EVIL - private static InternalSource _instance; - - [Export(typeof(IInitializable))] - private class InternalSource : IInitializable - { - [ImportingConstructor] - public InternalSource(IBus bus) { - publisher = new StatePublisher(bus.subscribe(SparkTags.SecuritiesTag) - .Select(m => m.Values.Select(s => s.security).Ordered(SecurityDataHelper.Comparer.Instance).ToArray())); - _instance = this; - } - - internal readonly StatePublisher publisher; - - public int priority => int.MaxValue; - public void initialize() { } + readonly IObservable securities; + public IObservable GetObservable() { + return securities; } } } \ No newline at end of file diff --git a/src/client/spark/mspark/Shell/Fills/FillsVM.cs b/src/client/spark/mspark/Shell/Fills/FillsVM.cs index dd39990c8..2cb6e04c3 100644 --- a/src/client/spark/mspark/Shell/Fills/FillsVM.cs +++ b/src/client/spark/mspark/Shell/Fills/FillsVM.cs @@ -24,7 +24,7 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "Fills"; - public FillsVM(IBus bus, OrdersModel model, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { + public FillsVM(IBus bus, OrdersModel model, SecuritySource ssrc, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { _bus = bus; _model = model; _securities = new HashSet(securities ?? Enumerable.Empty()); @@ -41,7 +41,7 @@ namespace mbts.spark secs => { _securities = new HashSet(secs); _update(); - }) + }, ssrc) }, () => true, true, -12, -30); } diff --git a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs index 69b7fb964..ad45debb8 100644 --- a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs +++ b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuItemVM.cs @@ -16,17 +16,17 @@ namespace mbts.spark.menu_items internal class LaunchMenuItemVM : MenuItemVM, IHaveTemplate, IDisposable { #region Static Factory - public static IList CreateMenu(params IMenuItem[] models) { - return models.Select(Create).ToList(); + public static IList CreateMenu(SecuritySource ssrc, params IMenuItem[] models) { + return models.Select(i => Create(i, ssrc)).ToList(); } - public static LaunchMenuItemVM Create(IMenuItem model) { + public static LaunchMenuItemVM Create(IMenuItem model, SecuritySource ssrc) { var act_mi = model as IMenuActionItem; if (act_mi != null) return Create(act_mi); var secs_mi = model as IMenuSecuritiesActionItem; - if (secs_mi != null) return Create(secs_mi); + if (secs_mi != null) return Create(secs_mi, ssrc); var grp_mi = model as IMenuGroupItem; - if (grp_mi != null) return Create(grp_mi); + if (grp_mi != null) return Create(grp_mi, ssrc); throw new NotImplementedException("LaunchMenuVM cannot create vm for {0} ({1}).".fmt(model?.display_name ?? "unnamed", model?.GetType().ToString() ?? "null")); } @@ -36,7 +36,7 @@ namespace mbts.spark.menu_items return new LaunchMenuItemVM(model.display_name, model.sectional_id, model.icon, command, Template.Action, dispose:model as IDisposable); } - public static LaunchMenuItemVM Create(IMenuSecuritiesActionItem model) { + public static LaunchMenuItemVM Create(IMenuSecuritiesActionItem model, SecuritySource ssrc) { SecurityLaunchMenuItem rv = null; IDisposable sub = null; IRaiseCanExecuteChangedCommand command = null; @@ -45,14 +45,14 @@ namespace mbts.spark.menu_items rv.selected_securities.Clear(); sub = rv.selected_securities.Subscribe((s, e) => command.RaiseCanExecuteChanged()); }, () => model.can_execute(rv.selected_securities)); - rv = new SecurityLaunchMenuItem(model.display_name, model.sectional_id, model.icon, command, Template.Securities, Disposable.Create(() => { (model as IDisposable)?.Dispose(); sub?.Dispose(); })); + rv = new SecurityLaunchMenuItem(model.display_name, model.sectional_id, model.icon, command, Template.Securities, Disposable.Create(() => { (model as IDisposable)?.Dispose(); sub?.Dispose(); }), ssrc); sub = rv.selected_securities.Subscribe((s, e) => command.RaiseCanExecuteChanged()); model.can_execute_changed += () => command.RaiseCanExecuteChanged(); return rv; } - public static LaunchMenuItemVM Create(IMenuGroupItem model) { - return new LaunchMenuItemVM(model.display_name, model.sectional_id, model.icon, template_key:Template.Group, items:CreateMenu(model.items.ToArray())); + public static LaunchMenuItemVM Create(IMenuGroupItem model, SecuritySource ssrc) { + return new LaunchMenuItemVM(model.display_name, model.sectional_id, model.icon, template_key:Template.Group, items:CreateMenu(ssrc, model.items.ToArray())); } #endregion @@ -66,9 +66,12 @@ namespace mbts.spark.menu_items internal class SecurityLaunchMenuItem : LaunchMenuItemVM { - internal SecurityLaunchMenuItem(string display_name, string sectional_id, ImageSource icon, ICommand launch_command, Template template_key, IDisposable dispose) - : base(display_name, sectional_id, icon, template_key:template_key, dispose:dispose) { this.launch_command = launch_command; } - private RXObservableCollection _securities = new RXObservableCollection(SecuritySource.GetObservable()); + internal SecurityLaunchMenuItem(string display_name, string sectional_id, ImageSource icon, ICommand launch_command, Template template_key, IDisposable dispose, SecuritySource src) + : base(display_name, sectional_id, icon, template_key:template_key, dispose:dispose) { + this.launch_command = launch_command; + _securities = new RXObservableCollection(src.GetObservable()); + } + private RXObservableCollection _securities; public RXObservableCollection securities => _securities; public ObservableCollection selected_securities { get; } = new ObservableCollection(); public ICommand launch_command { get; } diff --git a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuVM.cs b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuVM.cs index d1b31e342..177ea5a7b 100644 --- a/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuVM.cs +++ b/src/client/spark/mspark/Shell/LaunchMenu/LaunchMenuVM.cs @@ -7,8 +7,8 @@ namespace mbts.spark { internal class LaunchMenuVM : ViewModelBase { - public LaunchMenuVM(params IMenuItem[] models) { - var vms = LaunchMenuItemVM.CreateMenu(models); + public LaunchMenuVM(SecuritySource ssrc, params IMenuItem[] models) { + var vms = LaunchMenuItemVM.CreateMenu(ssrc, models); items_view = CollectionViewSource.GetDefaultView(vms); items_view.GroupDescriptions.Add(new PropertyGroupDescription(nameof(IMenuItem.sectional_id))); } diff --git a/src/client/spark/mspark/Shell/MarketModule.cs b/src/client/spark/mspark/Shell/MarketModule.cs index 3b88bd3f4..5e654114d 100644 --- a/src/client/spark/mspark/Shell/MarketModule.cs +++ b/src/client/spark/mspark/Shell/MarketModule.cs @@ -23,8 +23,9 @@ namespace mbts.spark [Export(typeof(IShellModule))] internal class MarketModule : IShellModule { [ImportingConstructor] - public MarketModule(IBus bus, IWindowManager wm) { + public MarketModule(IBus bus, SecuritySource ssrc, IWindowManager wm) { _bus = bus; + _ssrc = ssrc; _wm = wm; _dispose = Disposable.Create( _bus.subscribe(SecuritiesTag).ObserveOnDispatcher().Subscribe(s => _securities = s), @@ -41,6 +42,7 @@ namespace mbts.spark ); } private readonly IBus _bus; + private readonly SecuritySource _ssrc; private readonly IWindowManager _wm; private readonly IDisposable _dispose; private IReadOnlyDictionary _securities = new Dictionary(); @@ -51,6 +53,7 @@ namespace mbts.spark public ImageSource icon => Icons.Date; public IShellWindow launch_ui => new LaunchMenu { DataContext = new LaunchMenuVM( + _ssrc, new MarketViewMenuItem(_bus), new SpreadMatrixMenuItem(_bus), new LadderMenuItem(_bus), @@ -78,13 +81,13 @@ namespace mbts.spark public void Dispose() { _dispose.Dispose(); } #region SecurityBrowser - private void show_security_browser() { new SecurityBrowser { DataContext = new SecurityBrowserVM(_bus) }.Show(-200, -300, true); } + private void show_security_browser() { new SecurityBrowser { DataContext = new SecurityBrowserVM(_bus, _ssrc) }.Show(-200, -300, true); } #endregion #region MarketView private void show_market_view(ShowMarketViewMessage msg) { _wm.Windows.Add(create_market_view(msg.data, null)); } private IShellWindow create_market_view(IReadOnlyCollection securities, IReadOnlyCollection sorting) { - var vm = new MarketViewVM(_bus, securities, sorting); + var vm = new MarketViewVM(_bus, _ssrc, securities, sorting); var view = new MarketViewView { DataContext = vm }; const double two_thirds = 2.0 / 3.0; const double title_panel_height = 32.0, col_header_height = 26 + two_thirds + 10.0; diff --git a/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs index 00c424c39..dc6dbd8c4 100644 --- a/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/ModifySecuritySelectionMenuItem.cs @@ -9,14 +9,16 @@ namespace mbts.spark.menu_items { internal class ModifySecuritySelectionMenuItem : IMenuActionItem { - public ModifySecuritySelectionMenuItem(IReadOnlyCollection securities, Action> commit, string dialog_title="Select Securities") { + public ModifySecuritySelectionMenuItem(IReadOnlyCollection securities, SecuritySource ssrc, Action> commit, string dialog_title="Select Securities") { _securities = securities; + _ssrc = ssrc; _commit = commit; _dialog_title = dialog_title; } private readonly string _dialog_title; private readonly IReadOnlyCollection _securities; private readonly Action> _commit; + readonly SecuritySource _ssrc; public string display_name => "Add/Remove Securities"; public int priority => int.MinValue; public ImageSource icon => Icons.Coins; @@ -25,7 +27,7 @@ namespace mbts.spark.menu_items private IDisposable _dialog; public void execute() { Disposable.dispose(ref _dialog); - _dialog = new SecuritySelectorDialog { DataContext = new SecuritySelectorDialogVM(_dialog_title, _securities, _commit) }.Show(-12, -30, true); + _dialog = new SecuritySelectorDialog { DataContext = new SecuritySelectorDialogVM(_dialog_title, _securities, _commit, _ssrc) }.Show(-12, -30, true); } public event Action display_name_changed; public event Action can_execute_changed; diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs index f7967fea5..e4a4d1a6c 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs @@ -26,8 +26,9 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "TimeAndSales"; - public TimeAndSalesVM(IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { + public TimeAndSalesVM(IBus bus, IReadOnlyCollection securities, SecuritySource ssrc, IReadOnlyCollection sorting_criteria = null) { _bus = bus; + _ssrc = ssrc; _resources.Add(_model = new TimeAndSalesModel(bus, securities)); _rows = new ObservableAutoWrapper>(_trades, tup => new Row(tup.Item1, tup.Item2)); _rows.ViewDestroyed += r => r.Dispose(); @@ -52,6 +53,7 @@ namespace mbts.spark } private readonly IBus _bus; + readonly SecuritySource _ssrc; private readonly TimeAndSalesModel _model; private readonly ObservableCollection> _trades = new ObservableCollection>(); private readonly ObservableAutoWrapper> _rows; @@ -61,7 +63,7 @@ namespace mbts.spark private IOrderBook _order_book = new OrderBook(); private IEnumerable _context_menu_item_factory() { - yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(new HashSet(_rows.Select(r => r.security.value)), _model.set_securities)); + yield return MenuItemVM.Create(new ModifySecuritySelectionMenuItem(new HashSet(_rows.Select(r => r.security.value)), _ssrc, _model.set_securities)); if (current_cell != null && current_cell.Column != null && current_cell.Item != null && !current_cell.Item.Equals(System.Windows.DependencyProperty.UnsetValue)) { var securities = _rows.Where(r => r.is_selected).Select(r => r.security.value).ToList(); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs index aba5d04e3..ec02b6801 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesWindow.cs @@ -12,17 +12,19 @@ namespace mbts.spark { internal class TimeAndSalesWindow : IShellWindow { - public TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities) : this (owner, bus, securities, null) { } - public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data) : this(owner, bus, startup_data.securities.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria) { } + public TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, SecuritySource ssrc) : this (owner, bus, securities, ssrc, null) { } + public TimeAndSalesWindow(IShellModule owner, IBus bus, TimeAndSalesVM.StartupData startup_data, SecuritySource ssrc) : this(owner, bus, startup_data.securities.Select(x => (SecurityImmutable)deserialize(x)).ToList(), ssrc, startup_data.sorting_criteria) { } - private TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { + private TimeAndSalesWindow(IShellModule owner, IBus bus, IReadOnlyCollection securities, SecuritySource ssrc, IReadOnlyCollection sorting_criteria) { _bus = bus; + _ssrc = ssrc; _securities = securities; _sorting_criteria = sorting_criteria; _owner = owner; } private readonly IBus _bus; + readonly SecuritySource _ssrc; private readonly IReadOnlyCollection _securities; private readonly IReadOnlyCollection _sorting_criteria; private TimeAndSalesVM _vm; @@ -37,7 +39,7 @@ namespace mbts.spark public event Action TitleChanged; public event Action IconChanged; public void Dispose() { Disposable.dispose(ref _vm); } - public ShellWindowUI GetContent() { return new ShellWindowUI(new TimeAndSalesView { DataContext = _vm = new TimeAndSalesVM(_bus, _securities, _sorting_criteria), Width = 400, Height = 500 }); } + public ShellWindowUI GetContent() { return new ShellWindowUI(new TimeAndSalesView { DataContext = _vm = new TimeAndSalesVM(_bus, _securities, _ssrc, _sorting_criteria), Width = 400, Height = 500 }); } public void GetState(Stream save_here) { if (_vm != null) { serialize(save_here, new ShellSerializationHeader { name = TimeAndSalesVM.SAVE_NAME, version = TimeAndSalesVM.VERSION }); diff --git a/src/client/spark/mspark/Shell/TradesModule.cs b/src/client/spark/mspark/Shell/TradesModule.cs index 54b03548e..dd7ef3ee4 100644 --- a/src/client/spark/mspark/Shell/TradesModule.cs +++ b/src/client/spark/mspark/Shell/TradesModule.cs @@ -21,8 +21,9 @@ namespace mbts.spark internal class TradesModule : IShellModule { [ImportingConstructor] - public TradesModule(IBus bus, IWindowManager wm) { + public TradesModule(IBus bus, IWindowManager wm, SecuritySource ssrc) { _bus = bus; + _ssrc = ssrc; _wm = wm; _dispose = Disposable.Create( _bus.subscribe(ShowOrderBookTag).ObserveOnDispatcher().Subscribe(show_order_book), @@ -34,6 +35,7 @@ namespace mbts.spark } private readonly IBus _bus; + readonly SecuritySource _ssrc; private readonly IWindowManager _wm; private readonly IDisposable _dispose; @@ -42,6 +44,7 @@ namespace mbts.spark public ImageSource icon => Icons.Trades; public IShellWindow launch_ui => new LaunchMenu { DataContext = new LaunchMenuVM( + _ssrc, new OrderBookMenuItem(_bus), new FillsMenuItem(_bus), new AuditLogsMenuItem(_bus), @@ -55,7 +58,7 @@ namespace mbts.spark switch(header?.name) { case OrderBookVM.SAVE_NAME: if (try_deserialize(load_stream, out OrderBookState orders_state)) return Task.FromResult(create_order_book_window(orders_state)); break; case FillsVM.SAVE_NAME: { if (try_deserialize(load_stream, out FillsVM.StartupData state)) return Task.FromResult(create_fills_window(state)); break; } - case TimeAndSalesVM.SAVE_NAME: { if (try_deserialize(load_stream, out TimeAndSalesVM.StartupData state)) return Task.FromResult(new TimeAndSalesWindow(this, _bus, state)); break; } + case TimeAndSalesVM.SAVE_NAME: { if (try_deserialize(load_stream, out TimeAndSalesVM.StartupData state)) return Task.FromResult(new TimeAndSalesWindow(this, _bus, state, _ssrc)); break; } } return Task.FromResult(null); } @@ -71,7 +74,7 @@ namespace mbts.spark private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria); } private IShellWindow create_fills_window(IReadOnlyCollection securities) { return create_fills_window(securities, null); } private IShellWindow create_fills_window(IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { - var vm = new FillsVM(_bus, new OrdersModel(_bus), securities, sorting_criteria); + var vm = new FillsVM(_bus, new OrdersModel(_bus), _ssrc, securities, sorting_criteria); var view = new FillsView { DataContext = vm, Width = 1024, Height = 800 }; return ShellWindow.create(this, "Fills", view, vm.get_state, Icons.Ticket); } @@ -80,6 +83,6 @@ namespace mbts.spark private void show_fills(ShowFillsMessage msg) { _wm.Windows.Add(create_fills_window(new List())); } private void show_audit_log(ShowAuditLogsMessage msg) { } private void show_positions(ShowPositionsMessage msg) { } - private void show_time_and_sales(ShowTimeAndSalesMessage msg) { _wm.Windows.Add(new TimeAndSalesWindow(this, _bus, msg.data)); } + private void show_time_and_sales(ShowTimeAndSalesMessage msg) { _wm.Windows.Add(new TimeAndSalesWindow(this, _bus, msg.data, _ssrc)); } } } \ No newline at end of file From 4781fdac1e6c5c83391901fb7860f9c360a94daf Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Mon, 13 Nov 2017 11:14:46 -0500 Subject: [PATCH 24/29] Re-use the same ~/spark directory when doing windows->linux replication --- tools/replicator/replicate_to_linux_vm.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/replicator/replicate_to_linux_vm.py b/tools/replicator/replicate_to_linux_vm.py index a2667bd67..a2243d5c9 100644 --- a/tools/replicator/replicate_to_linux_vm.py +++ b/tools/replicator/replicate_to_linux_vm.py @@ -28,7 +28,7 @@ repo_root = os.path.abspath(repo_root) repo_name = os.path.basename(repo_root) profile_loc = os.path.join(os.path.abspath(os.environ['USERPROFILE']),'.unison') spark_profile = spark_profile.replace("$SOURCE", repo_root) -spark_profile = spark_profile.replace("$TARGET", repo_name) +spark_profile = spark_profile.replace("$TARGET", "spark") spark_profile = spark_profile.replace("$PORT", os.getenv("SPARKVM_UNISON_PORT", "8080")) From dc06d44f820d0d2662b7a4c36ef5d67c6dc2bdc6 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Mon, 13 Nov 2017 11:37:22 -0500 Subject: [PATCH 25/29] Remove ImportedResources.UserName singleton. --- src/client/spark/mspark/Shell/MarketModule.cs | 6 ++++-- src/client/spark/mspark/Utilities/ImportedResources.cs | 5 +---- src/client/spark/mspark/Utilities/OrderDataHelper.cs | 2 +- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/src/client/spark/mspark/Shell/MarketModule.cs b/src/client/spark/mspark/Shell/MarketModule.cs index 5e654114d..5bd4c94d8 100644 --- a/src/client/spark/mspark/Shell/MarketModule.cs +++ b/src/client/spark/mspark/Shell/MarketModule.cs @@ -23,10 +23,11 @@ namespace mbts.spark [Export(typeof(IShellModule))] internal class MarketModule : IShellModule { [ImportingConstructor] - public MarketModule(IBus bus, SecuritySource ssrc, IWindowManager wm) { + public MarketModule(IBus bus, SecuritySource ssrc, IWindowManager wm, [Import("username")]string user_name) { _bus = bus; _ssrc = ssrc; _wm = wm; + _user_name = user_name; _dispose = Disposable.Create( _bus.subscribe(SecuritiesTag).ObserveOnDispatcher().Subscribe(s => _securities = s), _bus.subscribe(SyntheticSecuritiesTag).ObserveOnDispatcher().Subscribe(ssm => _synthetic_strategy_map = ssm.data), @@ -45,6 +46,7 @@ namespace mbts.spark private readonly SecuritySource _ssrc; private readonly IWindowManager _wm; private readonly IDisposable _dispose; + private readonly string _user_name; private IReadOnlyDictionary _securities = new Dictionary(); private IDictionary _synthetic_strategy_map = new Dictionary(); @@ -111,7 +113,7 @@ namespace mbts.spark private void show_order_ticket(IReadOnlyCollection orders, bool is_modify) { foreach (var o in orders) { if (_securities.TryGetValue(o.Security.Id, out SecurityMD smd)) { - if (string.IsNullOrEmpty(o.User)) o.User = ImportedResources.UserName; + if (string.IsNullOrEmpty(o.User)) o.User = _user_name; var vm = new OrderTicketVM(new OrdersModel(_bus), o, _get_ladder_settings()); (is_modify ? (Window)new OrderModificationDialog { DataContext = vm } : new OrderTicket { DataContext = vm }).Show(-200, -160, true); } diff --git a/src/client/spark/mspark/Utilities/ImportedResources.cs b/src/client/spark/mspark/Utilities/ImportedResources.cs index 9b5272e51..9aebac166 100644 --- a/src/client/spark/mspark/Utilities/ImportedResources.cs +++ b/src/client/spark/mspark/Utilities/ImportedResources.cs @@ -12,7 +12,6 @@ namespace mbts.spark.utilities internal static class ImportedResources { public static IBus Bus => _instance.bus; - public static string UserName => _instance.user_name; public static readonly string[] Accounts = new[] { "Account1", "Account2", "Account3", "Account4" }; #region Misc Extensions (should put these in a more appropriate place eventually) @@ -33,13 +32,11 @@ namespace mbts.spark.utilities private class HiddenInstance : IInitializable { [ImportingConstructor] - public HiddenInstance(IBus bus, [Import("username")]string user_name) { + public HiddenInstance(IBus bus) { this.bus = bus; - this.user_name = user_name; } internal readonly IBus bus; - internal readonly string user_name; public int priority => int.MaxValue; public void initialize() { _instance = this; } diff --git a/src/client/spark/mspark/Utilities/OrderDataHelper.cs b/src/client/spark/mspark/Utilities/OrderDataHelper.cs index 29e5aa50b..25950a2d4 100644 --- a/src/client/spark/mspark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/mspark/Utilities/OrderDataHelper.cs @@ -43,7 +43,7 @@ namespace mbts.spark.utilities public static Order Order(SecurityImmutable security, Order.AlgoOrderTypeOneofCase algo_type) { var rv = new Order { Account = ImportedResources.Accounts.FirstOrDefault(), - User = ImportedResources.UserName, + User = "bts", Security = security.CloneToMutable(), }; switch (algo_type) { From ff8c4abc49ddbae66d5d4e6795b700193441569d Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Mon, 13 Nov 2017 12:06:11 -0500 Subject: [PATCH 26/29] Make ImportedResources.ToSecurity accept the bus so dependencies are clear. --- .../spark/mspark/MarketView/MarketViewVM.cs | 2 +- .../spark/mspark/Orders/OrderTicketVM.cs | 6 ++-- src/client/spark/mspark/Shell/MarketModule.cs | 4 +-- .../Shell/TimeAndSales/TimeAndSalesVM.cs | 2 +- src/client/spark/mspark/Utilities/BBOVM.cs | 6 ++-- .../spark/mspark/Utilities/ISecurityMDPump.cs | 24 +++++++------- .../mspark/Utilities/ImportedResources.cs | 32 ++++--------------- 7 files changed, 28 insertions(+), 48 deletions(-) diff --git a/src/client/spark/mspark/MarketView/MarketViewVM.cs b/src/client/spark/mspark/MarketView/MarketViewVM.cs index a79bf3823..f47bcc885 100644 --- a/src/client/spark/mspark/MarketView/MarketViewVM.cs +++ b/src/client/spark/mspark/MarketView/MarketViewVM.cs @@ -67,7 +67,7 @@ namespace mbts.spark var curr_col = (Columns)DataGridEx.GetArgument(current_cell.Column); var securities = _rows_vm.Where(r => r.is_selected).Select(r => r.security.value).ToList(); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); - yield return MenuItemVM.Create(new LinkedLadderMenuItem(_bus, _get_current_security_observable().ToSecurityMD())); + yield return MenuItemVM.Create(new LinkedLadderMenuItem(_bus, _get_current_security_observable().ToSecurityMD(_bus))); yield return MenuItemVM.Create(new OrderTicketMenuItem(_model.orders_model, s => _create_order(_rows_vm.First(r => r.security.value.Equals(s)), curr_col)), securities); yield return MenuItemVM.Create(new LinkedOrderTicketMenuItem(_bus, _current_cell.Select(_create_order))); yield return MenuItemVM.Create(new SpreadMatrixMenuItem(_bus), securities); diff --git a/src/client/spark/mspark/Orders/OrderTicketVM.cs b/src/client/spark/mspark/Orders/OrderTicketVM.cs index 13fb3d61f..7a6586e8b 100644 --- a/src/client/spark/mspark/Orders/OrderTicketVM.cs +++ b/src/client/spark/mspark/Orders/OrderTicketVM.cs @@ -10,8 +10,8 @@ namespace mbts.spark { internal class OrderTicketVM : DisposableViewModelBase { - public OrderTicketVM(OrdersModel model, Order order, IObservable settings) : this(model, Observable.Return(order), settings) { } - public OrderTicketVM(OrdersModel model, IObservable order, IObservable settings) { + public OrderTicketVM(OrdersModel model, Order order, IObservable settings, IBus bus) : this(model, Observable.Return(order), settings, bus) { } + public OrderTicketVM(OrdersModel model, IObservable order, IObservable settings, IBus bus) { var order_pub = order.Select(o => { _order = o; size_calculator.value = _order.Size; @@ -19,7 +19,7 @@ namespace mbts.spark return _order; }).Publish(); order_params = new OrderParamsVM(order_pub, model); - bbo = new BBOVM(order.Select(o => (SecurityImmutable)o.Security)); + bbo = new BBOVM(order.Select(o => (SecurityImmutable)o.Security), bus); size_calculator = new CalculatorLogic(0, settings.Select(s => s.calculator_buttons)); set_price_command = new DelegateCommand(p => { price = p; RaisePropertyChanged(nameof(price)); }); send_order = new DelegateCommand(side => { _prepare_order(side); model.send_order(_order); }); diff --git a/src/client/spark/mspark/Shell/MarketModule.cs b/src/client/spark/mspark/Shell/MarketModule.cs index 5bd4c94d8..d13165633 100644 --- a/src/client/spark/mspark/Shell/MarketModule.cs +++ b/src/client/spark/mspark/Shell/MarketModule.cs @@ -114,14 +114,14 @@ namespace mbts.spark foreach (var o in orders) { if (_securities.TryGetValue(o.Security.Id, out SecurityMD smd)) { if (string.IsNullOrEmpty(o.User)) o.User = _user_name; - var vm = new OrderTicketVM(new OrdersModel(_bus), o, _get_ladder_settings()); + var vm = new OrderTicketVM(new OrdersModel(_bus), o, _get_ladder_settings(), _bus); (is_modify ? (Window)new OrderModificationDialog { DataContext = vm } : new OrderTicket { DataContext = vm }).Show(-200, -160, true); } } } private void show_linked_order_ticket(ShowLinkedOrderTicketMessage msg) { new OrderTicket { - DataContext = new OrderTicketVM(new OrdersModel(_bus), msg.data, _get_ladder_settings()) + DataContext = new OrderTicketVM(new OrdersModel(_bus), msg.data, _get_ladder_settings(), _bus) }.Show(-200, -160, true); } #endregion diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs index e4a4d1a6c..bb32bcfa8 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesVM.cs @@ -67,7 +67,7 @@ namespace mbts.spark if (current_cell != null && current_cell.Column != null && current_cell.Item != null && !current_cell.Item.Equals(System.Windows.DependencyProperty.UnsetValue)) { var securities = _rows.Where(r => r.is_selected).Select(r => r.security.value).ToList(); yield return MenuItemVM.Create(new LadderMenuItem(_bus), securities); - yield return MenuItemVM.Create(new LinkedLadderMenuItem(_bus, _get_current_security_observable().ToSecurityMD())); + yield return MenuItemVM.Create(new LinkedLadderMenuItem(_bus, _get_current_security_observable().ToSecurityMD(_bus))); yield return MenuItemVM.Create(new OrderTicketMenuItem(_model.orders_model), securities); yield return MenuItemVM.Create(new LinkedOrderTicketMenuItem(_bus, _get_current_security_observable().Select(OrderDataHelper.Defaults.Order))); yield return MenuItemVM.Create(new MarketViewMenuItem(_bus), securities); diff --git a/src/client/spark/mspark/Utilities/BBOVM.cs b/src/client/spark/mspark/Utilities/BBOVM.cs index 385483f36..a08ddd395 100644 --- a/src/client/spark/mspark/Utilities/BBOVM.cs +++ b/src/client/spark/mspark/Utilities/BBOVM.cs @@ -8,9 +8,9 @@ namespace mbts.spark { internal class BBOVM : DisposableViewModelBase { - public BBOVM(uint security) : this(Observable.Return(security)) { } - public BBOVM(IObservable security) : this(security.ToSecurity()) { } - public BBOVM(IObservable security) : this(security, new SecurityMDPump(security)) { } + public BBOVM(uint security, IBus bus) : this(Observable.Return(security), bus) { } + public BBOVM(IObservable security, IBus bus) : this(security.ToSecurity(bus), bus) { } + public BBOVM(IObservable security, IBus bus) : this(security, new SecurityMDPump(security, bus)) { } public BBOVM(IObservable security, ISecurityMDPump md_pump) { _security = backing(nameof(security), security, Security.Empty); _bid = backing(nameof(bid), md_pump.bid_price, double.NaN); diff --git a/src/client/spark/mspark/Utilities/ISecurityMDPump.cs b/src/client/spark/mspark/Utilities/ISecurityMDPump.cs index e81bcb669..c38dace88 100644 --- a/src/client/spark/mspark/Utilities/ISecurityMDPump.cs +++ b/src/client/spark/mspark/Utilities/ISecurityMDPump.cs @@ -27,18 +27,18 @@ namespace mbts.spark.utilities internal class SecurityMDPump : ISecurityMDPump, IDisposable { - public SecurityMDPump(SecurityImmutable security) : this(security, WorkLoop.DefaultPollInterval) { } - public SecurityMDPump(SecurityImmutable security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } - public SecurityMDPump(SecurityImmutable security, IObservable poll) : this(security.Id, poll) { } - public SecurityMDPump(IObservable security) : this(security.Select(s => s.Id)) { } - public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security.Select(s => s.Id), poll_interval) { } - public SecurityMDPump(IObservable security, IObservable poll) : this(security.Select(s => s.Id), poll) { } - public SecurityMDPump(uint security) : this(security, WorkLoop.DefaultPollInterval) { } - public SecurityMDPump(uint security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } - public SecurityMDPump(uint security, IObservable poll) : this(Observable.Return(security).ToSecurity(), poll) { } - public SecurityMDPump(IObservable security) : this(security, WorkLoop.DefaultPollInterval) { } - public SecurityMDPump(IObservable security, TimeSpan poll_interval) : this(security, Observable.Interval(poll_interval)) { } - public SecurityMDPump(IObservable security, IObservable poll) : this(security.CombineLatest(ImportedResources.Bus.subscribe(SparkTags.SecuritiesTag), (s, m) => m.GetValueOrDefault(s).md).Where(md => md != null), poll) { } + public SecurityMDPump(SecurityImmutable security, IBus bus) : this(security, WorkLoop.DefaultPollInterval, bus) { } + public SecurityMDPump(SecurityImmutable security, TimeSpan poll_interval, IBus bus) : this(security, Observable.Interval(poll_interval), bus) { } + public SecurityMDPump(SecurityImmutable security, IObservable poll, IBus bus) : this(security.Id, poll, bus) { } + public SecurityMDPump(IObservable security, IBus bus) : this(security.Select(s => s.Id), bus) { } + public SecurityMDPump(IObservable security, TimeSpan poll_interval, IBus bus) : this(security.Select(s => s.Id), poll_interval, bus) { } + public SecurityMDPump(IObservable security, IObservable poll, IBus bus) : this(security.Select(s => s.Id), poll, bus) { } + public SecurityMDPump(uint security, IBus bus) : this(security, WorkLoop.DefaultPollInterval, bus) { } + public SecurityMDPump(uint security, TimeSpan poll_interval, IBus bus) : this(security, Observable.Interval(poll_interval), bus) { } + public SecurityMDPump(uint security, IObservable poll, IBus bus) : this(Observable.Return(security).ToSecurity(bus), poll, bus) { } + public SecurityMDPump(IObservable security, IBus bus) : this(security, WorkLoop.DefaultPollInterval, bus) { } + public SecurityMDPump(IObservable security, TimeSpan poll_interval, IBus bus) : this(security, Observable.Interval(poll_interval), bus) { } + public SecurityMDPump(IObservable security, IObservable poll, IBus bus) : this(security.CombineLatest(bus.subscribe(SparkTags.SecuritiesTag), (s, m) => m.GetValueOrDefault(s).md).Where(md => md != null), poll) { } public SecurityMDPump(IMDHandle md) : this(Observable.Return(md)) { } public SecurityMDPump(IMDHandle md, TimeSpan poll_interval) : this(Observable.Return(md), poll_interval) { } public SecurityMDPump(IMDHandle md, IObservable poll) : this(Observable.Return(md), poll) { } diff --git a/src/client/spark/mspark/Utilities/ImportedResources.cs b/src/client/spark/mspark/Utilities/ImportedResources.cs index 9aebac166..498f2b163 100644 --- a/src/client/spark/mspark/Utilities/ImportedResources.cs +++ b/src/client/spark/mspark/Utilities/ImportedResources.cs @@ -5,41 +5,21 @@ using System; using System.ComponentModel.Composition; using System.Reactive.Linq; using static mbts.spark.SparkTags; -using MDMap = System.Collections.Generic.Dictionary; namespace mbts.spark.utilities { internal static class ImportedResources { - public static IBus Bus => _instance.bus; public static readonly string[] Accounts = new[] { "Account1", "Account2", "Account3", "Account4" }; - #region Misc Extensions (should put these in a more appropriate place eventually) - public static IObservable ToSecurity(this IObservable securityKey) { - return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk).security); + public static IObservable ToSecurity(this IObservable securityKey, IBus bus) { + return securityKey.CombineLatest(bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk).security); } - public static IObservable ToSecurityMD(this IObservable securityKey) { - return securityKey.CombineLatest(Bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk)); + public static IObservable ToSecurityMD(this IObservable securityKey, IBus bus) { + return securityKey.CombineLatest(bus.subscribe(SecuritiesTag), (sk, map) => map.GetValueOrDefault(sk)); } - public static IObservable ToSecurityMD(this IObservable security) { - return security.CombineLatest(Bus.subscribe(SecuritiesTag), (s, map) => map.GetValueOrDefault(s.Id)); - } - #endregion - - private static HiddenInstance _instance; - - [Export(typeof(IInitializable))] - private class HiddenInstance : IInitializable - { - [ImportingConstructor] - public HiddenInstance(IBus bus) { - this.bus = bus; - } - - internal readonly IBus bus; - - public int priority => int.MaxValue; - public void initialize() { _instance = this; } + public static IObservable ToSecurityMD(this IObservable security, IBus bus) { + return security.CombineLatest(bus.subscribe(SecuritiesTag), (s, map) => map.GetValueOrDefault(s.Id)); } } } \ No newline at end of file From 440c33a267b81bb4de1626da916ceae442b03519 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Mon, 13 Nov 2017 13:59:16 -0500 Subject: [PATCH 27/29] Rename OrdersModel DemoOrdersModel to make it's temporary nature more obvious --- src/client/spark/mspark/Core/PositionSource.cs | 4 ++-- src/client/spark/mspark/Ladder/LadderModel.cs | 6 +++--- src/client/spark/mspark/MarketView/MarketViewModel.cs | 6 +++--- src/client/spark/mspark/Orders/OrderParamsVM.cs | 6 +++--- src/client/spark/mspark/Orders/OrderTicketVM.cs | 4 ++-- src/client/spark/mspark/Orders/OrdersModel.cs | 4 ++-- .../spark/mspark/SecurityBrowser/SecurityBrowserVM.cs | 2 +- src/client/spark/mspark/Shell/Fills/FillsVM.cs | 8 ++++---- src/client/spark/mspark/Shell/MarketModule.cs | 10 +++++----- .../mspark/Shell/MenuItems/CancelOrderRootMenuItem.cs | 8 ++++---- .../mspark/Shell/MenuItems/CancelOrdersMenuItem.cs | 8 ++++---- .../mspark/Shell/MenuItems/ModifyOrderRootMenuItem.cs | 8 ++++---- .../mspark/Shell/MenuItems/OrderTicketMenuItem.cs | 4 ++-- .../spark/mspark/Shell/OrderBook/OrderBookRowVM.cs | 4 ++-- src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs | 4 ++-- .../mspark/Shell/TimeAndSales/TimeAndSalesModel.cs | 6 +++--- src/client/spark/mspark/Shell/TradesModule.cs | 4 ++-- 17 files changed, 48 insertions(+), 48 deletions(-) diff --git a/src/client/spark/mspark/Core/PositionSource.cs b/src/client/spark/mspark/Core/PositionSource.cs index fde9c4891..c52ae9e6d 100644 --- a/src/client/spark/mspark/Core/PositionSource.cs +++ b/src/client/spark/mspark/Core/PositionSource.cs @@ -14,11 +14,11 @@ namespace mbts.spark [ImportingConstructor] public PositionSource(IBus bus) { _bus = bus; - _orders_model = new OrdersModel(_bus); + _orders_model = new DemoOrdersModel(_bus); } private readonly IBus _bus; - private readonly OrdersModel _orders_model; + private readonly DemoOrdersModel _orders_model; public int priority => int.MaxValue; diff --git a/src/client/spark/mspark/Ladder/LadderModel.cs b/src/client/spark/mspark/Ladder/LadderModel.cs index f36504873..4f5a8e3ae 100644 --- a/src/client/spark/mspark/Ladder/LadderModel.cs +++ b/src/client/spark/mspark/Ladder/LadderModel.cs @@ -14,9 +14,9 @@ namespace mbts.spark { class LadderModel { - private OrdersModel _order_gateway; + private DemoOrdersModel _order_gateway; - public LadderModel(SecurityMD source, OrdersModel ordergw) { + public LadderModel(SecurityMD source, DemoOrdersModel ordergw) { security = source.security; md = source.md; _order_gateway = ordergw; @@ -32,6 +32,6 @@ namespace mbts.spark { Logger.info(bts.log.Subsystem.Ui, $"Cancel {ct}"); } - public OrdersModel order_gateway => _order_gateway; + public DemoOrdersModel order_gateway => _order_gateway; } } \ No newline at end of file diff --git a/src/client/spark/mspark/MarketView/MarketViewModel.cs b/src/client/spark/mspark/MarketView/MarketViewModel.cs index 6b469bfdc..b4cadaf72 100644 --- a/src/client/spark/mspark/MarketView/MarketViewModel.cs +++ b/src/client/spark/mspark/MarketView/MarketViewModel.cs @@ -19,11 +19,11 @@ namespace mbts.spark _subs.Add(_bus.subscribe(PositionsTag).Subscribe(m => { foreach (var kv in m.data) _positions_demuxer.push_data(kv.Key, kv.Value); })); - _orders_model = new OrdersModel(_bus); + _orders_model = new DemoOrdersModel(_bus); } private readonly IBus _bus; - private readonly OrdersModel _orders_model; + private readonly DemoOrdersModel _orders_model; private readonly Subject> _securities_subject = new Subject>(); private readonly ObservableDemuxer _positions_demuxer = new ObservableDemuxer(k => 0); private IList _subs = new List(); @@ -31,7 +31,7 @@ namespace mbts.spark public IObservable> rows => _bus.subscribe(SecuritiesTag).StartWith(new Dictionary()).CombineLatest(_securities_subject, (md, secs) => md.Intersect(secs, kv => kv.Key).Select(kv => kv.Value)); public IReadOnlyCollection all_securities => _data.Values.Select(s => s.security).ToList(); - public OrdersModel orders_model => _orders_model; + public DemoOrdersModel orders_model => _orders_model; public IObservable security_position(security_key key) { return _positions_demuxer.subscribe(key).DistinctUntilChanged(); } public void show_ladder(SecurityImmutable security) { _bus.post(ShowLadderTag, new ShowLadderMessage(security)); } diff --git a/src/client/spark/mspark/Orders/OrderParamsVM.cs b/src/client/spark/mspark/Orders/OrderParamsVM.cs index feb866f16..985181ee7 100644 --- a/src/client/spark/mspark/Orders/OrderParamsVM.cs +++ b/src/client/spark/mspark/Orders/OrderParamsVM.cs @@ -14,8 +14,8 @@ namespace mbts.spark { internal class OrderParamsVM : DisposableViewModelBase { - public OrderParamsVM(Order order, OrdersModel model) : this(Observable.Return(order), model) { } - public OrderParamsVM(IObservable order, OrdersModel model) { + public OrderParamsVM(Order order, DemoOrdersModel model) : this(Observable.Return(order), model) { } + public OrderParamsVM(IObservable order, DemoOrdersModel model) { _model = model; _dispose = order.Subscribe(o => { _order = o; @@ -26,7 +26,7 @@ namespace mbts.spark algo_types = new ObservableCollection(_get_algo_types()); } - private readonly OrdersModel _model; + private readonly DemoOrdersModel _model; private Order _order = new Order { LimitOrder = new LimitOrder() }; private IEnumerable _get_algo_types() { diff --git a/src/client/spark/mspark/Orders/OrderTicketVM.cs b/src/client/spark/mspark/Orders/OrderTicketVM.cs index 7a6586e8b..a3722ae99 100644 --- a/src/client/spark/mspark/Orders/OrderTicketVM.cs +++ b/src/client/spark/mspark/Orders/OrderTicketVM.cs @@ -10,8 +10,8 @@ namespace mbts.spark { internal class OrderTicketVM : DisposableViewModelBase { - public OrderTicketVM(OrdersModel model, Order order, IObservable settings, IBus bus) : this(model, Observable.Return(order), settings, bus) { } - public OrderTicketVM(OrdersModel model, IObservable order, IObservable settings, IBus bus) { + public OrderTicketVM(DemoOrdersModel model, Order order, IObservable settings, IBus bus) : this(model, Observable.Return(order), settings, bus) { } + public OrderTicketVM(DemoOrdersModel model, IObservable order, IObservable settings, IBus bus) { var order_pub = order.Select(o => { _order = o; size_calculator.value = _order.Size; diff --git a/src/client/spark/mspark/Orders/OrdersModel.cs b/src/client/spark/mspark/Orders/OrdersModel.cs index 55565dcbb..4123374f8 100644 --- a/src/client/spark/mspark/Orders/OrdersModel.cs +++ b/src/client/spark/mspark/Orders/OrdersModel.cs @@ -14,13 +14,13 @@ using mbts.utils; namespace mbts.spark { - class OrdersModel + class DemoOrdersModel { private readonly IBus _bus; private IObservable _on_orderbook; private IDictionary _synth_map = new Dictionary (); - public OrdersModel(IBus bus) + public DemoOrdersModel(IBus bus) { _bus = bus; _on_orderbook = _bus.subscribe(SparkTags.OrderBookTag) diff --git a/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs b/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs index a451b60ec..46c0a3c6b 100644 --- a/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs +++ b/src/client/spark/mspark/SecurityBrowser/SecurityBrowserVM.cs @@ -7,7 +7,7 @@ namespace mbts.spark internal class SecurityBrowserVM : SecuritySelectorVM { public SecurityBrowserVM(IBus bus, SecuritySource ssrc) :base(ssrc) { - var orders_model = new OrdersModel(bus); + var orders_model = new DemoOrdersModel(bus); _actions = MenuItemVM.CreateMenu(selected_securities, new CancelOrdersMenuItem(orders_model), new SyntheticCreateMenuItem(bus), new SyntheticStrategyMenuItem(bus), new OrderTicketMenuItem(orders_model)); _windows = MenuItemVM.CreateMenu(selected_securities, new LadderMenuItem(bus), new MarketViewMenuItem(bus), new SpreadMatrixMenuItem(bus), new TimeAndSalesMenuItem(bus)); } diff --git a/src/client/spark/mspark/Shell/Fills/FillsVM.cs b/src/client/spark/mspark/Shell/Fills/FillsVM.cs index 2cb6e04c3..0769d6bd8 100644 --- a/src/client/spark/mspark/Shell/Fills/FillsVM.cs +++ b/src/client/spark/mspark/Shell/Fills/FillsVM.cs @@ -24,7 +24,7 @@ namespace mbts.spark public const int VERSION = 1; public const string SAVE_NAME = "Fills"; - public FillsVM(IBus bus, OrdersModel model, SecuritySource ssrc, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { + public FillsVM(IBus bus, DemoOrdersModel model, SecuritySource ssrc, IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria = null) { _bus = bus; _model = model; _securities = new HashSet(securities ?? Enumerable.Empty()); @@ -46,7 +46,7 @@ namespace mbts.spark } private readonly IBus _bus; - private readonly OrdersModel _model; + private readonly DemoOrdersModel _model; private readonly ObservableCollection _fills = new ObservableCollection(); private readonly ObservableAutoWrapper _rows; private HashSet _securities; @@ -88,7 +88,7 @@ namespace mbts.spark } private class Row { - public Row(FillTuple fill, OrdersModel model) { + public Row(FillTuple fill, DemoOrdersModel model) { _fill = fill.Fill; _entry = fill.OrderBookEntry; _model = model; @@ -97,7 +97,7 @@ namespace mbts.spark foreach (var f in _entry.Fills) if (f.Timestamp <= _fill.Timestamp) aggr_fills += f.Size; order_percentage = (double)aggr_fills / (double)_fill.Order.Size; } - private readonly OrdersModel _model; + private readonly DemoOrdersModel _model; private readonly Fill _fill; private readonly OrderBookEntry _entry; public OrderBookEntry entry => _entry; diff --git a/src/client/spark/mspark/Shell/MarketModule.cs b/src/client/spark/mspark/Shell/MarketModule.cs index d13165633..d37de5341 100644 --- a/src/client/spark/mspark/Shell/MarketModule.cs +++ b/src/client/spark/mspark/Shell/MarketModule.cs @@ -59,7 +59,7 @@ namespace mbts.spark new MarketViewMenuItem(_bus), new SpreadMatrixMenuItem(_bus), new LadderMenuItem(_bus), - new OrderTicketMenuItem(new OrdersModel(_bus)), + new OrderTicketMenuItem(new DemoOrdersModel(_bus)), MenuItemFactory.Create("Security Browser...", "sb", Icons.Coins, execute: show_security_browser)) }; public void load_state(Stream state = null) { } @@ -114,14 +114,14 @@ namespace mbts.spark foreach (var o in orders) { if (_securities.TryGetValue(o.Security.Id, out SecurityMD smd)) { if (string.IsNullOrEmpty(o.User)) o.User = _user_name; - var vm = new OrderTicketVM(new OrdersModel(_bus), o, _get_ladder_settings(), _bus); + var vm = new OrderTicketVM(new DemoOrdersModel(_bus), o, _get_ladder_settings(), _bus); (is_modify ? (Window)new OrderModificationDialog { DataContext = vm } : new OrderTicket { DataContext = vm }).Show(-200, -160, true); } } } private void show_linked_order_ticket(ShowLinkedOrderTicketMessage msg) { new OrderTicket { - DataContext = new OrderTicketVM(new OrdersModel(_bus), msg.data, _get_ladder_settings(), _bus) + DataContext = new OrderTicketVM(new DemoOrdersModel(_bus), msg.data, _get_ladder_settings(), _bus) }.Show(-200, -160, true); } #endregion @@ -131,7 +131,7 @@ namespace mbts.spark private void show_ladder(SecurityMD sec) { _wm.Windows.Add(create_ladder_window(sec)); } private async void show_linked_ladder(ShowLinkedLadderMessage msg) { _wm.Windows.Add(await create_ladder_window(msg.data)); } private IShellWindow create_ladder_window(SecurityMD md) { - var model = new LadderModel(md, new OrdersModel(_bus)); + var model = new LadderModel(md, new DemoOrdersModel(_bus)); var vm = new LadderVM(model, _get_ladder_settings()); var view = new LadderView { DataContext = vm }; return ShellWindow.create(this, md.security.ToString(null), view, vm, vm.save_state, Icons.Depth); @@ -139,7 +139,7 @@ namespace mbts.spark private IObservable _get_ladder_settings() { return Observable.Return(new LadderSettings()); } private async Task create_ladder_window(IObservable security_md) { var first_smd = await security_md.FirstAsync(); - OrdersModel om = new OrdersModel(_bus); + DemoOrdersModel om = new DemoOrdersModel(_bus); LadderVM vm = new LadderVM(new LadderModel(first_smd, om), _get_ladder_settings()); LadderView view = new LadderView { DataContext = vm }; IDisposable sub = null; diff --git a/src/client/spark/mspark/Shell/MenuItems/CancelOrderRootMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/CancelOrderRootMenuItem.cs index 0e5060e0b..82d914254 100644 --- a/src/client/spark/mspark/Shell/MenuItems/CancelOrderRootMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/CancelOrderRootMenuItem.cs @@ -7,21 +7,21 @@ namespace mbts.spark.menu_items { internal class CancelOrderRootMenuItem : OrderActionMenuItemRoot { - public CancelOrderRootMenuItem(OrdersModel model, IReadOnlyCollection orders) : base(orders) { + public CancelOrderRootMenuItem(DemoOrdersModel model, IReadOnlyCollection orders) : base(orders) { _model = model; } - private OrdersModel _model; + private DemoOrdersModel _model; public override string display_name => "Cancel Order"; public override ImageSource icon => Icons.CancelOrders; protected override OrderMenuActionItem create_item(Order order) { return new CancelOrderMenuItem(_model, order); } internal class CancelOrderMenuItem : OrderMenuActionItem { - public CancelOrderMenuItem(OrdersModel model, Order order) : base(order, model.get_metadata(order)) { + public CancelOrderMenuItem(DemoOrdersModel model, Order order) : base(order, model.get_metadata(order)) { _model = model; _order = order; } - private readonly OrdersModel _model; + private readonly DemoOrdersModel _model; private readonly Order _order; public override void execute() { _model.cancel_order(_order.Id); } } diff --git a/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs index 59bc0bae9..048be9ba6 100644 --- a/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/CancelOrdersMenuItem.cs @@ -10,12 +10,12 @@ namespace mbts.spark.menu_items { internal class CancelOrdersMenuItem : IMenuSecuritiesActionItem { - public CancelOrdersMenuItem(OrdersModel model) { + public CancelOrdersMenuItem(DemoOrdersModel model) { _model = model; _sub = _model.on_orderbook().ObserveOnDispatcher().Subscribe(ob => _orderbook = ob); } private readonly IDisposable _sub; - private readonly OrdersModel _model; + private readonly DemoOrdersModel _model; private IOrderBook _orderbook = new OrderBook(); public virtual string display_name => "Cancel All Orders"; @@ -36,13 +36,13 @@ namespace mbts.spark.menu_items } internal class CancelBuyOrdersMenuItem : CancelOrdersMenuItem { - public CancelBuyOrdersMenuItem(OrdersModel model) : base(model) { } + public CancelBuyOrdersMenuItem(DemoOrdersModel model) : base(model) { } public override string display_name => "Cancel Buy Orders"; protected override bool filter(Order order) { return order.Side == Side.Buy; } } internal class CancelSellOrdersMenuItem : CancelOrdersMenuItem { - public CancelSellOrdersMenuItem(OrdersModel model) : base(model) { } + public CancelSellOrdersMenuItem(DemoOrdersModel model) : base(model) { } protected override bool filter(Order order) { return order.Side == Side.Sell; } public override string display_name => "Cancel Sell Orders"; } diff --git a/src/client/spark/mspark/Shell/MenuItems/ModifyOrderRootMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/ModifyOrderRootMenuItem.cs index 45e80636c..74c1eb188 100644 --- a/src/client/spark/mspark/Shell/MenuItems/ModifyOrderRootMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/ModifyOrderRootMenuItem.cs @@ -11,21 +11,21 @@ namespace mbts.spark.menu_items { internal class ModifyOrderRootMenuItem : OrderActionMenuItemRoot { - public ModifyOrderRootMenuItem(OrdersModel model, IReadOnlyCollection orders) : base(orders) { + public ModifyOrderRootMenuItem(DemoOrdersModel model, IReadOnlyCollection orders) : base(orders) { _model = model; } - private OrdersModel _model; + private DemoOrdersModel _model; public override string display_name => "Modify Order"; public override ImageSource icon => Icons.Import; protected override OrderMenuActionItem create_item(Order order) { return new ModifyOrderMenuItem(_model, order); } internal class ModifyOrderMenuItem : OrderMenuActionItem { - public ModifyOrderMenuItem(OrdersModel model, Order order) : base(order, model.get_metadata(order)) { + public ModifyOrderMenuItem(DemoOrdersModel model, Order order) : base(order, model.get_metadata(order)) { _model = model; _order = order; } - private readonly OrdersModel _model; + private readonly DemoOrdersModel _model; private readonly Order _order; public override void execute() { _model.show_order_modify(_order); } } diff --git a/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs b/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs index 88e6e2a49..9b420dc40 100644 --- a/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs +++ b/src/client/spark/mspark/Shell/MenuItems/OrderTicketMenuItem.cs @@ -13,12 +13,12 @@ namespace mbts.spark.menu_items { internal class OrderTicketMenuItem : IMenuSecuritiesActionItem { - public OrderTicketMenuItem(OrdersModel model, Func order_factory=null) { + public OrderTicketMenuItem(DemoOrdersModel model, Func order_factory=null) { _model = model; _order_factory = order_factory ?? new Func(s => new Order { Security = s.CloneToMutable(), LimitOrder = new LimitOrder(), Size = 1 }); } - private readonly OrdersModel _model; + private readonly DemoOrdersModel _model; private readonly Func _order_factory; public string display_name => "Order Ticket"; diff --git a/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs b/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs index 8af4a9111..5d7898a33 100644 --- a/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs +++ b/src/client/spark/mspark/Shell/OrderBook/OrderBookRowVM.cs @@ -10,10 +10,10 @@ namespace mbts.spark { class OrderBookRowVM : ViewModelBase { readonly OrderBookVM _parent; - readonly OrdersModel _model; + readonly DemoOrdersModel _model; OrderBookEntry _order; - public OrderBookRowVM(OrderBookVM parent, OrdersModel model, OrderBookEntry entry) { + public OrderBookRowVM(OrderBookVM parent, DemoOrdersModel model, OrderBookEntry entry) { _parent = parent; _model = model; _order = entry; diff --git a/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs b/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs index da9afb041..edff3b584 100644 --- a/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs +++ b/src/client/spark/mspark/Shell/OrderBook/OrderBookVM.cs @@ -17,9 +17,9 @@ using System.Windows.Input; namespace mbts.spark { class OrderBookVM : DisposableViewModelBase { public const string SAVE_NAME = "SparkOrderBookWindow"; - readonly OrdersModel _model; + readonly DemoOrdersModel _model; - public OrderBookVM(IBus bus, OrdersModel model, OrderBookState state, IObservable settings) { + public OrderBookVM(IBus bus, DemoOrdersModel model, OrderBookState state, IObservable settings) { _bus = bus; _model = model; diff --git a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs index b7af9bf12..ff06cc52a 100644 --- a/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs +++ b/src/client/spark/mspark/Shell/TimeAndSales/TimeAndSalesModel.cs @@ -14,12 +14,12 @@ namespace mbts.spark { public TimeAndSalesModel(IBus bus, IReadOnlyCollection securities) { set_securities(securities); - _orders_model = new OrdersModel(bus); + _orders_model = new DemoOrdersModel(bus); _work_loop = WorkLoop.Start(_refresh); } private readonly IDisposable _work_loop; - private readonly OrdersModel _orders_model; + private readonly DemoOrdersModel _orders_model; private readonly Subject>> _trades = new Subject>>(); private readonly Dictionary _channels = new Dictionary(); @@ -37,7 +37,7 @@ namespace mbts.spark public IObservable>> trades => _trades.AsObservable(); public IReadOnlyCollection securities => _channels.Keys; - public OrdersModel orders_model => _orders_model; + public DemoOrdersModel orders_model => _orders_model; public void set_securities(IEnumerable securities) { var real_secs = securities.SelectMany(_get_real_securities); diff --git a/src/client/spark/mspark/Shell/TradesModule.cs b/src/client/spark/mspark/Shell/TradesModule.cs index dd7ef3ee4..658e582c2 100644 --- a/src/client/spark/mspark/Shell/TradesModule.cs +++ b/src/client/spark/mspark/Shell/TradesModule.cs @@ -66,7 +66,7 @@ namespace mbts.spark public void Dispose() { _dispose.Dispose(); } private IShellWindow create_order_book_window(OrderBookState state) { - var vm = new OrderBookVM(_bus, new OrdersModel(_bus), state, Observable.Return(new OrderBookSettings())); + var vm = new OrderBookVM(_bus, new DemoOrdersModel(_bus), state, Observable.Return(new OrderBookSettings())); var view = new OrderBookView(vm) { Width = 1526, Height = 800 }; return ShellWindow.create(this, "Order Book", view, vm.get_state); } @@ -74,7 +74,7 @@ namespace mbts.spark private IShellWindow create_fills_window(FillsVM.StartupData startup_data) { return create_fills_window(startup_data.securities?.Select(x => (SecurityImmutable)deserialize(x)).ToList(), startup_data.sorting_criteria); } private IShellWindow create_fills_window(IReadOnlyCollection securities) { return create_fills_window(securities, null); } private IShellWindow create_fills_window(IReadOnlyCollection securities, IReadOnlyCollection sorting_criteria) { - var vm = new FillsVM(_bus, new OrdersModel(_bus), _ssrc, securities, sorting_criteria); + var vm = new FillsVM(_bus, new DemoOrdersModel(_bus), _ssrc, securities, sorting_criteria); var view = new FillsView { DataContext = vm, Width = 1024, Height = 800 }; return ShellWindow.create(this, "Fills", view, vm.get_state, Icons.Ticket); } From 59d960af31515df942204c882891b3e92f45c3b0 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Mon, 13 Nov 2017 14:02:59 -0500 Subject: [PATCH 28/29] Delete some unused code --- src/client/spark/mspark/Orders/IOrderBook.cs | 19 ------------------- 1 file changed, 19 deletions(-) diff --git a/src/client/spark/mspark/Orders/IOrderBook.cs b/src/client/spark/mspark/Orders/IOrderBook.cs index ae479d993..e99fdef4e 100644 --- a/src/client/spark/mspark/Orders/IOrderBook.cs +++ b/src/client/spark/mspark/Orders/IOrderBook.cs @@ -13,35 +13,16 @@ namespace mbts.spark static class OrderBookExtensions { - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_orders_for_security(security.Id); } - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_orders_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_all_orders_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders().Where(e => e.sec_key() == security); } - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_orders_for_security(new HashSet(securities)); } - public static IEnumerable get_all_orders_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders().Where(e => securities.Contains(e.sec_key())); } public static IDictionary> get_order_sec_map(this IOrderBook ob) { return ob.get_all_orders().Map(e => e.sec_key()); } - public static IEnumerable get_active_orders(this IOrderBook ob) { return ob.get_all_orders().Where(e => e.is_active()); } - public static IEnumerable get_active_orders_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_active_orders_for_security(security.Id); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_active_orders_for_security(new HashSet(security.Select(s => s.Id))); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders().Where(e => e.sec_key() == security && e.is_active()); } - public static IEnumerable get_active_orders_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_active_orders_for_security(new HashSet(securities)); } public static IEnumerable get_active_orders_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders().Where(e => securities.Contains(e.sec_key()) && e.is_active()); } - public static IDictionary> get_active_order_sec_map(this IOrderBook ob) { return ob.get_active_orders().Map(e => e.sec_key()); } public static IEnumerable get_all_fills(this IOrderBook ob) { return ob.get_all_orders().SelectMany(e => e.Fills); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_fills_for_security(security.Id); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fills_for_security(new HashSet(security.Select(s => s.Id))); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders_for_security(security).SelectMany(e => e.Fills); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_fills_for_security(new HashSet(securities)); } - public static IEnumerable get_all_fills_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders_for_security(securities).SelectMany(e => e.Fills); } public static IDictionary> get_fill_sec_map(this IOrderBook ob) { return ob.get_all_fills().Map(f => f.Order.Security.Id); } - public static IEnumerable get_all_fill_tuples(this IOrderBook ob) { return ob.get_all_orders().SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, SecurityImmutable security) { return ob.get_all_fill_tuples_for_security(security.Id); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable security) { return ob.get_all_fill_tuples_for_security(new HashSet(security.Select(s => s.Id))); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, uint security) { return ob.get_all_orders_for_security(security).SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, IEnumerable securities) { return ob.get_all_fill_tuples_for_security(new HashSet(securities)); } - public static IEnumerable get_all_fill_tuples_for_security(this IOrderBook ob, HashSet securities) { return ob.get_all_orders_for_security(securities).SelectMany(e => e.Fills.Select(f => new FillTuple(f, e))); } public static IDictionary> get_fill_tuple_sec_map(this IOrderBook ob) { return ob.get_all_orders().Map(o => o.sec_key(), o => o.Fills.Select(f => new FillTuple(f, o))); } } From f3658e5a4554826053319e797d0aa63b22fdc894 Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Mon, 13 Nov 2017 14:00:59 -0600 Subject: [PATCH 29/29] CME audit file creation script --- src/server/sparkd/orderman/audit/audit_cme.py | 622 ++++++++++++++++++ 1 file changed, 622 insertions(+) create mode 100644 src/server/sparkd/orderman/audit/audit_cme.py diff --git a/src/server/sparkd/orderman/audit/audit_cme.py b/src/server/sparkd/orderman/audit/audit_cme.py new file mode 100644 index 000000000..d17cfa8f3 --- /dev/null +++ b/src/server/sparkd/orderman/audit/audit_cme.py @@ -0,0 +1,622 @@ +#!/usr/bin/python + +import os +import re +import fileinput +import sys +import collections +import csv +import datetime +import time +import copy +import itertools +import argparse + +# region fix record processing + +valid_message_types = { + 'D': 'NEW ORDER', + 'G': 'MODIFY', + 'F': 'CANCEL', + '8': 'EXECUTION', + 'i': 'MASS QUOTE', + 'R': 'QUOTE REQUEST', + 'b': 'QUOTE ACK', + 'Z': 'MASS QUOTE CANCEL', + # 'c': 'SECURITY DEFINITION REQUEST', + '3': 'SESSION LEVEL REJECT', + 'j': 'BUSINESS LEVEL REJECT', + '9': 'CANCEL REJECT', + 'CA': 'ORDER MASS ACTION REQUEST', + 'BZ': 'ORDER MASS ACTION REPORT' +} + +valid_order_types = { + '1': 'Market order (with protection)', + '2': 'Limit order', + '3': 'Stop order (with protection)', + '4': 'Stop-Limit order', + 'K': 'Market-Limit order' +} + +valid_order_status = { + '0': 'NEW ORDER ACK', + '1': 'PARTIAL FILL', + '2': 'COMPLETE FILL', + '4': 'CANCEL ACK', + '5': 'MODIFY ACK', + '8': 'ORDER REJECTED', + 'C': 'EXPIRED', + 'H': 'TRADE CANCEL', + 'U': 'CANCEL REJECTED' +} + +valid_sides = { + '1': 'BUY', + '2': 'SELL' +} + +# Range of values from tag 59 here: +# https://www.cmegroup.com/confluence/display/EPICSANDBOX/New+Order +valid_order_qualifier = { + '0': 'DAY', + '1': 'GTC', + '3': 'FAK', + '6': 'GTD' +} + +valid_quote_ack_status = { + '0': 'Accepted', + '1': 'Cancel per instrument accepted', + '3': 'Cancel per Instrument Group accepted', + '4': 'Cancel All accepted', + 'A': 'Cancel Hard Disconnect accepted', + 'B': 'Cancel Client Logout accepted', + 'C': 'Cancel GCC Eliminated All accepted', + 'D': 'Cancel GCC Eliminated Group accepted', + 'E': 'Expired accepted', + 'F': 'Cancel per Market Maker Protection accepted', + 'H': 'Cancel due to Self-Trade Prevention accepted', + '5': 'Rejected' +} + + +def is_an_audited_quote_message(fix_record): + if fix_record['35'] == 'b': + if '297' in fix_record and fix_record['297'] in valid_quote_ack_status: + return True + else: return False + else: + return False + + +valid_quote_reject_reason = { + '1': 'Unknown Symbol', + '2': 'Exchange (Security) closed', + '3': 'Quote request exceeds limit', + '5': 'Unknown quote', + '6': 'Duplicate quote', + '7': 'Invalid bid/ask spread', + '8': 'Invalid price', + '9': 'Not authorized to quote security', + '20': 'Too many rejects and cancel instrument group', + '98': 'Market maker protection', + '99': 'Missing account number or other reason' +} + + +def getter(field_name): + def result(fix_record): + if field_name in fix_record: + return fix_record[field_name] + else: + return None + return result + + +func_table = {} + + +def direction(fix_record): + if fix_record['49'] == 'CME': + return "FROM CME" + else: + return "TO CME" + + +func_table[5] = getter('7928') + + +def account_number(fix_record): + if '9771' in fix_record: + return fix_record['9771'] + elif '1' in fix_record: + return fix_record['1'] + else: + return None + + +func_table[6] = account_number + + +def session_id(fix_record): + if func_table[3] == 'TO CME': + return fix_record['49'][:3] + else: # FROM CME + return fix_record['56'][:3] + + +func_table[7] = session_id + + +def execution_firm_id(fix_record): + if func_table[3] == 'TO CME': + return fix_record['49'][3:6] + else: # FROM CME + return fix_record['56'][3:6] + + +func_table[8] = execution_firm_id +func_table[9] = getter('1028') + + +def message_type(fix_record): + if '35' in fix_record: + tag_35 = fix_record['35'] + if func_table[3] == 'TO CME': + if tag_35 == 'Z': + return tag_35 + '\\' + fix_record['298'] + else: + return tag_35 + else: # FROM CME + if tag_35 == '8': + return tag_35 + '\\' + fix_record['39'] + elif tag_35 == 'b': + return tag_35 + '\\' + fix_record['297'] + elif tag_35 == '9': + return tag_35 + '\\' + fix_record['434'] + else: + return tag_35 + else: + return None + + +func_table[10] = message_type +func_table[11] = getter('9702') +func_table[12] = getter('204') +func_table[13] = getter('17') +# func_table[14]=getter('none') +func_table[15] = getter('11') +func_table[16] = getter('527') + + +def instrument_description(fix_record): + if '107' in fix_record: + return fix_record['107'] + elif '9774' in fix_record: + return fix_record['9774'] + elif '55' in fix_record: + return fix_record['55'] + else: + return None + + +func_table[17]=instrument_description + + +def market_segment_id(fix_record): + if func_table[3] == 'TO CME': + return fix_record['57'] + else: + return fix_record['50'] + + +func_table[18] = market_segment_id +func_table[19] = getter('11') +func_table[20] = getter('37') + + +def buy_sell_indicator(fix_record): + if '54' in fix_record: + tag_54 = fix_record['54'] + if tag_54 == '1': + return 'B' + elif tag_54 == '2': + return 'S' + else: + return None + else: + return None + + +# func_table[21]=buy_sell_indicator +func_table[21] = getter('54') + + +def quantity(fix_record): + if '32' in fix_record: + return fix_record['32'] + elif '38' in fix_record: + return fix_record['38'] + else: + return None + + +func_table[22] = quantity +func_table[23] = getter('44') +func_table[24] = getter('99') + + +def order_type(fix_record): + if '40' in fix_record and fix_record['40'] in valid_order_types: + return valid_order_types[fix_record['40']] + else: + return None + + +# func_table[25]=order_type +func_table[25] = getter('40') + + +def order_qualifier(fix_record): + if '59' in fix_record and fix_record['59'] in valid_order_qualifier: + return valid_order_qualifier[fix_record['59']] + else: + return None + + +# func_table[26]=order_qualifier +func_table[26] = getter('59') +func_table[27] = getter('9768') +func_table[28] = getter('210') +func_table[29] = getter('110') + + +def country_of_origin(fix_record): + if '142' in fix_record: + # return '\'' + fix_record['142'] + '\'' + return fix_record['142'].replace(",", "") + else: + return None + + +func_table[30] = country_of_origin +func_table[31] = getter('31') +func_table[32] = getter('32') +func_table[33] = getter('14') +func_table[34] = getter('151') +func_table[35] = getter('1057') +func_table[36] = getter('378') + + +def strip_comment_of_comma(fix_record): + if '58' in fix_record: + # Execution Report - Reject + if '103' in fix_record: + return fix_record['103'] + ':' + fix_record['58'].replace(",", "") + # Cancel or Cancel-Replace Reject + elif '102' in fix_record: + return fix_record['102'] + ':' + fix_record['58'].replace(",", "") + # No reject code + else: + return fix_record['58'].replace(",", "") + elif '368' in fix_record: + # QuoteEntryRejectReason + return fix_record['368'].replace(",", "") + else: + return None + + +func_table[37] = strip_comment_of_comma +func_table[38] = getter('9772') +func_table[39] = getter('548') +func_table[40] = getter('131') +func_table[41] = getter('117') +func_table[42] = getter('299') +func_table[43] = getter('132') +func_table[44] = getter('134') +func_table[45] = getter('133') +func_table[46] = getter('135') + +# endregion + +# region audit message template +audit_message_templates = {} +# New Order & RFC +audit_message_templates['D'] = [range(1,13), range(14,16), range(17,20), range(21, 27), range(28,31), [39]] +audit_message_templates['s'] = [range(1,13), range(14,16), range(17,20), range(21, 27), range(28,31), [39]] +# Order Cancel Request +audit_message_templates['F'] = [range(1,5), range(6,11), range(14,16), range(17,22), [30]] +# Order Modifiction +audit_message_templates['G'] = [range(1,13), range(14,16), range(17,31)] +# Execution Report - Ack +audit_message_templates['8\\0'] = [range(1,11), range(13,16), range(17,27), range(28,30), [39]] +# Execution Report - Fill Notice - Partial & Complete +audit_message_templates['8\\1'] = [range(1,11), range(13,22), range(31,36), [39]] +audit_message_templates['8\\2'] = [range(1,11), range(13,22), range(31,36), [39]] +# Execution Report - Cancel Confirmation +audit_message_templates['8\\4'] = [range(1,11), range(13,16), range(17,22), [36], [39]] +# Execution Report - Modification Confirmation +audit_message_templates['8\\5'] = [range(1,11), range(13,16), range(17,27), range(28,30), [39]] +# Execution Report - Trade Cancel Confirmation +audit_message_templates['8\\H'] = [range(1,11), range(13,22), range(31,33)] +# Execution Report - Elimination Notice +audit_message_templates['8\\C'] = [range(1,11), range(13,16), range(17,22), range(33,35)] +# Execution Report - Reject +audit_message_templates['8\\8'] = [range(1,11), range(13,16), range(17,22), [37]] +# Session-Level Reject +audit_message_templates['3'] = [range(1,5), range(7,11), range(14,16), [18], [37]] +# Business-Level Reject +audit_message_templates['j'] = [range(1,5), range(7,11), range(14,16), [18], [37]] +# Cancel or Cancel-Replace Reject +audit_message_templates['9\\1'] = [range(1,5), range(6,11), range(13,16), range(18,21), [37]] +# Mass Quote +audit_message_templates['i'] = [range(1,13), range(17,19), [30], range(40,47)] +# Mass Quote - Ack +audit_message_templates['b\\0'] = [range(1,11), [18], range(37,39), range(41,43)] +# Mass Quote - Reject +audit_message_templates['b\\5'] = [range(1,11), [18], range(37,39), [41]] +# Mass Quote - Cancel - Per Instrument & Per Instrument Group & All Quotes +audit_message_templates['Z\\1'] = [range(1,6), range(7,11), range(17,19), [41]] +audit_message_templates['Z\\3'] = [range(1,6), range(7,11), range(17,19), [41]] +audit_message_templates['Z\\4'] = [range(1,6), range(7,11), range(17,19), [41]] +# Mass Quote Cancel Ack - various kinds +audit_message_templates['b\\1'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\3'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\4'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\A'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\B'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\C'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\D'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\E'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\F'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +audit_message_templates['b\\H'] = [range(1,6), range(7,11), range(17,19), range(37,39), range(41,43)] +# Mass Quote Cancel - Reject +# This shares the same key as as Mass Quote - Reject. The only difference in the template is that here we exclude +# position 6. +# Skipping for now since Spark will not quote; would need to have some other part to key off of as well +# Request For Quote (RFQ) +audit_message_templates['R'] = [range(1,6), range(7,11), [14], range(17,19), [21], [30], [40]] +# Quote Acknowledgement (RFQ) +# This shares the same key as as Mass Quote - Ack and Mass Quote - Reject +# Skipping for now since Spark will not RFQ; would need to have some other part to key off of as well +# Order Mass Action Request +audit_message_templates['CA\\1'] = [range(1,11), [14], range(17,20), [21], range(25,27), [30]] +audit_message_templates['CA\\9'] = [range(1,11), [14], range(17,20), [21], range(25,27), [30]] +audit_message_templates['CA\\10'] = [range(1,11), [14], range(17,20), [21], range(25,27), [30]] +# Order Mass Action Report +audit_message_templates['BZ\\1'] = [range(1,11), range(14,16), range(17,23), range(25,27), [30]] +audit_message_templates['BZ\\9'] = [range(1,11), range(14,16), range(17,23), range(25,27), [30]] +audit_message_templates['BZ\\10'] = [range(1,11), range(14,16), range(17,23), range(25,27), [30]] +# endregion + +header_cols = ['Sending Timestamps', + 'Receiving Timestamps', + 'Message Direction', + 'Operator ID', + 'Self-Match Prevention ID', + 'Account Number', + 'Session ID', + 'Executing Firm ID', + 'Manual Order Identifier', + 'Message Type', + 'Customer Type Indicator', + 'Origin', + 'CME Globex Message ID', + 'Message Link ID', + 'Order Flow ID', + 'Spread/Leg Link ID', + 'Instrument Description', + 'Market Segment ID', + 'Client Order ID', + 'CME Globex Order ID', + 'Buy/Sell Indicator', + 'Quantity', + 'Limit Price', + 'Stop Price', + 'Order Type', + 'Order Qualifier', + 'IFM Flag', + 'Display Quantity', + 'Minimum Quantity', + 'Country of Origin', + 'Fill Price', + 'Fill Quantity', + 'Cumulative Quantity', + 'Remaining Quantity', + 'Aggressor Flag', + 'Source of Cancellation', + 'Reject Reason', + 'Processed Quotes', + 'Cross ID', + 'Quote Request ID', + 'Message Quote ID', + 'Quote Entry ID', + 'Bid Price', + 'Bid Size', + 'Offer Price', + 'Offer Size'] +excluded_from_client_lines = ['Self-Match Prevention ID', + 'Session ID', + 'Executing Firm ID', + 'Manual Order Identifier', + 'Customer Type Indicator', + 'Origin','CME Globex Message ID', + 'Spread/Leg Link ID', + 'Market Segment ID', + 'CME Globex Order ID', + 'Source of Cancellation', + 'Processed Quotes', + 'Cross ID', + 'Quote Request ID', + 'Message Quote ID', + 'Quote Entry ID'] + + +def parse_fix_line(line): + ts = line[:21] + fix_line = line[24:].split('\1') + result = {} + result['timestamp'] = ts + for fix_field in fix_line: + rx = r"(?P\d+)?=(?P.*)" + match = re.match(rx,fix_field) + if match: + result[match.group('tag')] = match.group('value') + return result + + +def create_client_dict(exchange_dict, parsed_fix_record): + # replicate the exchange line with all existing fields + client_line_dict = copy.deepcopy(exchange_dict) + + if (exchange_dict['Message Direction'] == 'TO CME'): + client_line_dict['Receiving Timestamps'] = exchange_dict['Sending Timestamps'] + client_line_dict['Sending Timestamps'] = None + client_line_dict['Message Direction'] = 'FROM CLIENT' + client_line_dict['Message Type'] = valid_message_types[parsed_fix_record['35']] + else: + client_line_dict['Sending Timestamps'] = exchange_dict['Receiving Timestamps'] + client_line_dict['Receiving Timestamps'] = None + client_line_dict['Message Direction'] = 'TO CLIENT' + client_line_dict['Message Type'] = valid_order_status[parsed_fix_record['39']] + + # clear out client fiends not required for audit + for k in excluded_from_client_lines: + client_line_dict[k] = None + + # Replace client lines with string descriptions to make them more readable + if '40' in parsed_fix_record: + client_line_dict['Order Type'] = valid_order_types[parsed_fix_record['40']] + else: + client_line_dict['Order Type'] = None + if '54' in parsed_fix_record: + client_line_dict['Buy/Sell Indicator'] = valid_sides[parsed_fix_record['54']] + else: + client_line_dict['Buy/Sell Indicator'] = None + if '59' in parsed_fix_record: + client_line_dict['Order Qualifier'] = valid_order_qualifier[parsed_fix_record['59']] + else: + client_line_dict['Order Qualifier'] = None + return client_line_dict + + +def write_output_csv(): + session_name = os.path.splitext(os.path.basename(args.quickfix_log))[0] + # with statement guarantees file closure regardless of matter how the block exists + output_file_name = "{0}_{1}_audittrail_{2:%Y%m%d}.csv".format("CME", session_name, args.date) + with open(output_file_name, 'wb') as outfile: + writer = csv.DictWriter(outfile, fieldnames=header_cols) + writer.writeheader() + writer.writerows(audit_entries) + + +def write_csv_to_console(): + console_writer = csv.DictWriter(sys.stdout, fieldnames=header_cols) + console_writer.writeheader() + console_writer.writerows(audit_entries) + + +def create_base_audit_entry(line_dict): + func_table[3] = direction(parsed_fix_record) + if func_table[3] == "TO CME": + func_table[4] = getter('50')(parsed_fix_record) + line_dict['Sending Timestamps'] = parsed_fix_record['timestamp'] + else: + func_table[4] = getter('57')(parsed_fix_record) + line_dict['Receiving Timestamps'] = parsed_fix_record['timestamp'] + line_dict['Message Direction'] = func_table[3] + line_dict['Operator ID'] = func_table[4] + # iterate through the whole function table for a fix line to generate an audit line + for field in range(5, 14): + value = func_table[field](parsed_fix_record) + if value: + line_dict[line_dict.keys()[field - 1]] = value.rstrip() + line_dict['Message Link ID'] = line_number + for field in range(15, 47): + value = func_table[field](parsed_fix_record) + if value: + line_dict[line_dict.keys()[field - 1]] = value.rstrip() + + +def enforce_template_contrainsts(line_dict): + # clear out composed audit fields that are not necessary in the particular message type + if line_dict['Message Type'] in audit_message_templates: + # 1-based, hence the +1 when comparing vs index + positions_to_keep = list(itertools.chain.from_iterable( + audit_message_templates[line_dict['Message Type']])) + for index, (key, value) in enumerate(line_dict.items()): + if index + 1 not in positions_to_keep: + line_dict[key] = None + + +def create_client_entries(line_dict): + if args.server_lines_only: + audit_entries.append(line_dict) + else: + client_line_dict = create_client_dict(line_dict, parsed_fix_record) + if line_dict['Message Direction'] == 'TO CME': + audit_entries.append(client_line_dict) + audit_entries.append(line_dict) + else: + audit_entries.append(line_dict) + audit_entries.append(client_line_dict) + + +def create_audit_line_from_fix_line(): + line_dict = collections.OrderedDict.fromkeys(header_cols) + create_base_audit_entry(line_dict) + enforce_template_contrainsts(line_dict) + create_client_entries(line_dict) + + +def valid_file(f): + if not os.path.exists(f): + # Argparse uses the ArgumentTypeError to give a rejection message like: + # error: argument input: x does not exist + raise argparse.ArgumentTypeError("{0} does not exist".format(f)) + return f + + +def valid_date(s): + try: + return datetime.datetime.strptime(s, "%Y%m%d") + except ValueError: + raise argparse.ArgumentTypeError("Not a valid date: '{0}'.".format(s)) + + +parser = argparse.ArgumentParser() +parser.add_argument("quickfix_log", help="the quickfix log[.gz] you wish to process", type=valid_file) +parser.add_argument("-d", "--date", help="the date you wish to parse from the log, specified as YYYYmmdd", + default=datetime.datetime.today().strftime("%Y%m%d"), type=valid_date) +parser.add_argument("-s", "--server_lines_only", + help="does not produce any TO/FROM CLIENT logs, useful for testing in CERT", action="store_true") +args = parser.parse_args() + +input_as_datetime = args.date +trade_day_start = input_as_datetime - datetime.timedelta(days=1) + datetime.timedelta(hours=16, minutes=30) +trade_day_utc_start = time.gmtime((time.mktime(trade_day_start.timetuple()))) +trade_day_end = input_as_datetime + datetime.timedelta(hours=16) +trade_day_utc_end = time.gmtime((time.mktime(trade_day_end.timetuple()))) + +file_opener = None +if args.quickfix_log.endswith(".gz"): + import gzip + file_opener = gzip.open +else: + file_opener = open + +audit_entries = [] +line_number = 0 +with file_opener(args.quickfix_log) as input_file: + for line in input_file: + line_timestamp = time.strptime(line[:21], "%Y%m%d-%H:%M:%S.%f") + if trade_day_utc_start <= line_timestamp <= trade_day_utc_end: + parsed_fix_record = parse_fix_line(line) + # if (record['35'] in valid_message_types and record['35'] != 'b') or (is_an_audited_quote_message(record)): + if parsed_fix_record['35'] in valid_message_types: + line_number = line_number + 1 + create_audit_line_from_fix_line() + +write_output_csv() +write_csv_to_console()