From 5cc9b8c8758917d6bd9b185ce6d4729708eb85d8 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 10 Jul 2018 19:09:37 -0400 Subject: [PATCH 01/16] SPARK-1404 trigger order proto's --- src/lib/api/services/OrderService.proto | 45 +++++++++++++++++++++++++ 1 file changed, 45 insertions(+) diff --git a/src/lib/api/services/OrderService.proto b/src/lib/api/services/OrderService.proto index 510fcd270..47d71bba2 100644 --- a/src/lib/api/services/OrderService.proto +++ b/src/lib/api/services/OrderService.proto @@ -84,6 +84,7 @@ message TickOrderDefinition {uint32 tick_offset_on_deploy = 1; spark.QuantityMe message LeanOrderDefinition {spark.QuantityMeasure cross_threshold = 1; uint32 max_chase_ticks = 2; CustomOrderDefinition child = 3; } message JoinOrderDefinition {uint32 tick_offset_on_deploy = 1; spark.QuantityMeasure join_threshold = 2; bool enable_hedge = 3; CustomOrderDefinition hedge = 4; int32 hedge_ticks = 5; CustomOrderDefinition child = 6;} message TopOrderDefinition {uint32 watch_level_tick_offset = 1; spark.QuantityMeasure top_threshold = 2; bool enable_hedge = 3; CustomOrderDefinition hedge = 4; int32 hedge_ticks = 5; CustomOrderDefinition child = 6;} +message TriggerOrderDefinition {TriggerCondition trigger_condition=1; TriggerAction trigger_action=2; CustomOrderDefinition child=3;} message OrderRecord { uint32 key = 1 [(bts.api.key)=true]; @@ -319,3 +320,47 @@ enum OrderError ORDER_ERROR_OK = 9; } +// Trigger Condition ///////////////////////////////// +////////////////////////////////////////////////////// +enum TriggerType{ + STOP = 0; + INVERSE_STOP = 1; +} +enum TriggerPriceType{ + BID = 0; + ASK = 1; + LAST_TRADE_PRICE = 2; +} +message TriggerQuantity{ + spark.QuantityMeasure quantity_measure = 10; + uint32 threshold_quantity = 20; +} +message AbsolutePriceTrigger{ + double trigger_price = 10; + // we can leave out qty for now + TriggerQuantity trigger_quantity = 20; +} +message TrailingTrigger{ + TriggerType trigger_type = 10; + int32 number_of_ticks = 20; +} +message TriggerCondition{ + TriggerPriceType price_type = 10; + oneof trigger{ + AbsolutePriceTrigger absolute_price_trigger = 20; + TrailingTrigger trailing_trigger = 30; + } +} +// Trigger Action //////////////////////////////////// +////////////////////////////////////////////////////// +message TriggerPayupPrice{ + TriggerPriceType price_type = 10; + int32 payup_ticks = 20; +} +message TriggerAction{ + uint32 security_id = 10; + oneof order_price{ + TriggerPayupPrice payup = 20; + double price = 30; + } +} \ No newline at end of file From 88ab4fbb79cff3d2f3132c377e79b4bc9d8647d3 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Thu, 12 Jul 2018 11:24:39 -0400 Subject: [PATCH 02/16] fixing build --- src/client/spark/view/Spark/Utilities/OrderDataHelper.cs | 4 ++-- src/lib/api/services/OrderService.proto | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index 065095fcd..2b6f3940e 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -311,8 +311,8 @@ namespace mbts.spark.utilities { public static PriceType PriceType => new PriceType { Status = PriceType.Types.Status.Bid }; public static PriceOffset PriceOffset => new PriceOffset { PriceType = PriceType }; public static QuantityTrigger QuantityTrigger => new QuantityTrigger { QuantityMeasure = QuantityMeasure, LessThanEqualto = true }; - public static AbsolutePriceTrigger AbsolutePriceTrigger => new AbsolutePriceTrigger { PriceType = PriceType, QuantityTrigger = QuantityTrigger }; - public static TrailingTrigger TrailingTrigger => new TrailingTrigger { PriceType = PriceType, Stop = true }; + public static bts.spark.AbsolutePriceTrigger AbsolutePriceTrigger => new bts.spark.AbsolutePriceTrigger { PriceType = PriceType, QuantityTrigger = QuantityTrigger }; + public static bts.spark.TrailingTrigger TrailingTrigger => new bts.spark.TrailingTrigger { PriceType = PriceType, Stop = true }; public static PriceTrigger PriceTrigger => new PriceTrigger { AbsolutePriceTrigger = AbsolutePriceTrigger, TrailingTrigger = TrailingTrigger }; public static OrderTime OrderTime => new OrderTime { Now = true }; public static BTSTimedWindowParameters TimeWindow => new BTSTimedWindowParameters { Cancel = true, StartTime = OrderTime, StopTime = new OrderTime() }; diff --git a/src/lib/api/services/OrderService.proto b/src/lib/api/services/OrderService.proto index 47d71bba2..8ec205619 100644 --- a/src/lib/api/services/OrderService.proto +++ b/src/lib/api/services/OrderService.proto @@ -359,7 +359,7 @@ message TriggerPayupPrice{ } message TriggerAction{ uint32 security_id = 10; - oneof order_price{ + oneof orderprice{ TriggerPayupPrice payup = 20; double price = 30; } From 0f7625ff4a1dc35213efc948b5f0101b07a07b35 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 16 Jul 2018 08:39:22 -0400 Subject: [PATCH 03/16] Conditional Order mostly done --- src/lib/api/services/OrderService.proto | 6 +- .../orderman/order_factory/OrderFactory.cpp | 5 +- .../sparkd/orderman/orders/TriggerOrder.cpp | 262 ++++++++++++++++++ .../sparkd/orderman/orders/TriggerOrder.h | 61 ++++ .../orders/spreader_orders/SpreaderOrder.cpp | 2 +- 5 files changed, 331 insertions(+), 5 deletions(-) create mode 100644 src/server/sparkd/orderman/orders/TriggerOrder.cpp create mode 100644 src/server/sparkd/orderman/orders/TriggerOrder.h diff --git a/src/lib/api/services/OrderService.proto b/src/lib/api/services/OrderService.proto index 8ec205619..63d15cfea 100644 --- a/src/lib/api/services/OrderService.proto +++ b/src/lib/api/services/OrderService.proto @@ -68,6 +68,7 @@ message CustomOrderDefinition LeanOrderDefinition lean = 19; JoinOrderDefinition join = 20; TopOrderDefinition top = 21; + TriggerOrderDefinition trigger = 22; } } @@ -336,15 +337,14 @@ message TriggerQuantity{ uint32 threshold_quantity = 20; } message AbsolutePriceTrigger{ - double trigger_price = 10; // we can leave out qty for now - TriggerQuantity trigger_quantity = 20; + TriggerQuantity trigger_quantity = 10; } message TrailingTrigger{ TriggerType trigger_type = 10; int32 number_of_ticks = 20; } -message TriggerCondition{ +message TriggerCondition{ TriggerPriceType price_type = 10; oneof trigger{ AbsolutePriceTrigger absolute_price_trigger = 20; diff --git a/src/server/sparkd/orderman/order_factory/OrderFactory.cpp b/src/server/sparkd/orderman/order_factory/OrderFactory.cpp index 61a7af6c8..8a2681cc9 100644 --- a/src/server/sparkd/orderman/order_factory/OrderFactory.cpp +++ b/src/server/sparkd/orderman/order_factory/OrderFactory.cpp @@ -135,7 +135,10 @@ Order &OrderFactory::allocate(OrderKey k, OrderKey pk, break; case CustomOrderDefinition::kTop: order_ptr.reset (new orderman::TopOrder()); - break; + break; + case CustomOrderDefinition::kTrigger: + order_ptr.reset (new orderman::TopOrder()); + break; case CustomOrderDefinition::CUSTOM_NOT_SET: bts_assert(false); break; diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.cpp b/src/server/sparkd/orderman/orders/TriggerOrder.cpp new file mode 100644 index 000000000..f446c9f1f --- /dev/null +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -0,0 +1,262 @@ +#include "TriggerOrder.h" +#include "lib/logging/logging.h" +#include "lib/utils/PBUtils.h" +#include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h" +#include "server/sparkd/orderman/events/BookUpdateEvent.h" +#include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" +#include +#include + +namespace bts{ +namespace orderman{ + +struct TriggerOrder::PImpl { + OrderServices *services; + api::orderman::OrderDefinition order_def; + api::orderman::OrderState state; + api::orderman::OrderState child_state; + ChildOrder child_order; + Book book; + // this tells that when the order is placed + // initially, is the trigger price above the + // market (trigger_condition's chosen market) + bool trigger_above_market; + bool market_observed_once; + PImpl() + : + services(nullptr), + order_def(), + state(), + child_state(), + market_observed_once(false){ + } +}; + +TriggerOrder::TriggerOrder() +: +_state(State::START), +me(new PImpl()){ +} +TriggerOrder::~TriggerOrder(){ +} +const api::orderman::OrderDefinition& TriggerOrder::definition() const{ + return me->order_def; +} +void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os){ + switch (_state){ + case State::START: + _preinit(order_def,pre_os); + break; + case State::WAITING_FOR_TRIGGER: + case State::STEADY: + case State::END: + std::ostringstream oss; + oss << "TriggerOrder::on_init_new key:" << key() << "state:" << _state; + bts_assert_msg(false, oss.str()); + break; + } +} +void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord&, + const PreActivationOrderServices&){ + // mark it as completed and go to the end +} +void TriggerOrder::on_activate(Price price, + Quantity qty, + OrderServices& services, + TickToTradeCorID){ + switch (_state){ + case State::START: + me->state.set_price(price.value()); + me->state.set_quantity(qty.value()); + services.child_updates.sub(key(), + [this](const OrderStateUpdateEvent& os) + { this->_on_child_order_update (os);}); + services.book_updates.sub(SecurityKey(me->order_def.security_key()), + [this](const BookUpdateEvent& bk_event) + { this->_on_book_update (bk_event);}); + break; + case State::WAITING_FOR_TRIGGER: + case State::STEADY: + bts_assert(false); + break; + case State::END: + break; + } +} +// order price, qty change +void TriggerOrder::on_update(Price price, + Quantity qty, + TickToTradeCorID){ + switch (_state){ + case State::START: + me->state.set_price(price.value()); + me->state.set_quantity(qty.value()); + _report_state(); + break; + case State::WAITING_FOR_TRIGGER: + me->state.set_price(price.value()); + me->state.set_quantity(qty.value()); + _report_state(); + _analyze_trigger(); + break; + case State::STEADY: + // can not change it, send out a text msg + _report_state(); + break; + case State::END: + LOG(OrderMan, Warn, "TriggerOrder::on_update key:{} state:{}", + key(),_state); + break; + } +} +void TriggerOrder::on_crack(TickToTradeCorID){ + // not supported +} +void TriggerOrder::on_cancel(TickToTradeCorID){ + switch (_state){ + case State::START: + _switch_state(State::END); + break; + case State::WAITING_FOR_TRIGGER: + _switch_state(State::END); + break; + case State::STEADY: + me->child_order.cancel(); + _switch_state(State::END); + break; + case State::END: + LOG(OrderMan, Warn, "TriggerOrder::on_cancel key:{} state:{}", + key(),_state); + break; + } +} +void TriggerOrder::_on_book_update(const BookUpdateEvent& b_event){ + switch (_state){ + case State::WAITING_FOR_TRIGGER: + if(b_event.key().value()==me->order_def.security_key()){ + me->book=b_event.book; + _observe_market_once(); + if(me->market_observed_once) + _analyze_trigger(); + } + break; + case State::START: + case State::STEADY: + case State::END: + break; + } +} +void TriggerOrder::_on_child_order_update(const OrderStateUpdateEvent& o_ev){ + if(o_ev.key==me->child_order.key()){ + switch (_state){ + case State::START: + case State::WAITING_FOR_TRIGGER: + bts_assert(false); + break; + case State::STEADY: + me->child_state=o_ev.state; + if(SpreaderUtils::order_in_terminal_state(o_ev.state.status())) + _switch_state(State::END); + break; + case State::END: + break; + } + } +} +void TriggerOrder::_preinit(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os){ + me->order_def=order_def; + const auto& trigger_order_def=order_def.custom_def().trigger(); + api::orderman::OrderDefinition child_order_def = order_def; + child_order_def.set_security_key(trigger_order_def.trigger_action().security_id()); + child_order_def.mutable_custom_def()->CopyFrom(trigger_order_def.child()); + OrderBuilder order_builder=OrderBuilder(key(),child_order_def,pre_os); + me->child_order=order_builder.build(); +} +void TriggerOrder::_report_state(){ + bts_assert(me->services!=nullptr); + _compute_state(); + me->services->report_state(me->state); +} +void TriggerOrder::_switch_state(State new_state){ + switch(new_state){ + case State::START: + break; + case State::WAITING_FOR_TRIGGER: + bts_assert(_state=State::START); + break; + case State::STEADY: + bts_assert(_state==State::WAITING_FOR_TRIGGER); + break; + case State::END: + bts_assert(_state!=State::END); + break; + } + LOG(OrderMan, Info, "TriggerOrder::_report_state key:{} {}->{}", + key(), + _state,new_state); + _state=new_state; +} +void TriggerOrder::_analyze_trigger(){ + bts_assert(me->market_observed_once); + const md::PriceSize* eff_top=_eff_top(); + double trigger_price=_trigger_price(); + if((me->trigger_above_market && eff_top->price()>=trigger_price) || + (!me->trigger_above_market && eff_top->price()<=trigger_price)){ + me->child_order.activate(Price(_child_order_price()), + Quantity(me->state.quantity())); + _switch_state(State::STEADY); + } +} +api::orderman::OrderStatus TriggerOrder::_status(){ + switch(_state){ + case State::START: + case State::WAITING_FOR_TRIGGER: + case State::STEADY: + return api::orderman::OrderStatus::ORDER_STATUS_WORKING; + case State::END: + return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; + default: + bts_assert(false); + return api::orderman::OrderStatus::ORDER_STATUS_INACTIVE; + } +} +void TriggerOrder::_compute_state(){ + me->state.set_status(_status()); + me->state.set_filled_quantity(me->child_state.filled_quantity()); + me->state.set_last_price(me->child_state.last_price()); + me->state.set_avg_price(me->child_state.avg_price()); +} +void TriggerOrder::_observe_market_once(){ + if(!me->market_observed_once){ + const md::PriceSize* eff_top=_eff_top(); + if(eff_top != nullptr && eff_top->size()>0){ + me->market_observed_once=true; + me->trigger_above_market=_trigger_price()>=eff_top->price(); + } + } +} +const md::PriceSize* TriggerOrder::_eff_top() const{ + if(me->order_def.custom_def().trigger().trigger_condition().price_type()== + api::orderman::TriggerPriceType::BID){ + const auto& rv=me->book.bid()[0]; + return &rv; + } + else if (me->order_def.custom_def().trigger().trigger_condition().price_type()== + api::orderman::TriggerPriceType::ASK){ + const auto& rv=me->book.ask()[0]; + return &rv; + } + else{ + bts_assert(false); + return nullptr; + } +} +double TriggerOrder::_trigger_price() const{ + return me->state.price(); +} +double TriggerOrder::_child_order_price() const{ + return me->order_def.custom_def().trigger().trigger_action().price(); +} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.h b/src/server/sparkd/orderman/orders/TriggerOrder.h new file mode 100644 index 000000000..90f295cc6 --- /dev/null +++ b/src/server/sparkd/orderman/orders/TriggerOrder.h @@ -0,0 +1,61 @@ +#pragma once + +#include +#include "server/sparkd/orderman/orders/Order.h" +#include "lib/api/services/OrderService.server.pb.h" + +namespace bts { +namespace api {namespace orderman {class OrderDefinition;}} +namespace md {class PriceSize;} +namespace orderman { + +class OrderStateUpdateEvent; +class BookUpdateEvent; +class PreActivationOrderServices; + +class TriggerOrder : public Order +{ +private: + enum State{ + START=0, + WAITING_FOR_TRIGGER=1, + STEADY=2, + END=3 + }; +public: + TriggerOrder(); + ~TriggerOrder(); + api::orderman::OrderDefinition const&definition() const override; + void on_init_new(api::orderman::OrderDefinition const&, + const PreActivationOrderServices&) override; + void on_init_recovered(api::orderman::OrderRecord const&, + const PreActivationOrderServices &) override; + void on_activate(Price, Quantity, + OrderServices&, + TickToTradeCorID) override ; + void on_update(Price, Quantity, TickToTradeCorID) override; + void on_crack(TickToTradeCorID) override; + void on_cancel(TickToTradeCorID) override; +private: + // callbacks from orders and book + void _on_book_update(const BookUpdateEvent&); + void _on_child_order_update(OrderStateUpdateEvent const&); +private: + void _preinit(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os); + void _report_state(); + void _switch_state(State new_state); + void _analyze_trigger(); + api::orderman::OrderStatus _status(); + void _compute_state(); + void _observe_market_once(); + const md::PriceSize* _eff_top() const; + double _trigger_price() const; + double _child_order_price() const; +private: + State _state; + struct PImpl; + std::unique_ptr me; +}; + +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp index 23d1a241a..d31427dd8 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp @@ -320,7 +320,7 @@ void SpreaderOrder::_report_state (){ } // if order is cons'ed from disc, with inited_new==false, // we just publish what was given to us - LOG(OrderMan, Info, "SpreaderOrder::_report_state key: {} status: {} price: {} qty: {} filled: {} abg_price: {}", + LOG(OrderMan, Info, "SpreaderOrder::_report_state key: {} status: {} price: {} qty: {} filled: {} avg_price: {}", key(), status, reported_state.price(), reported_state.quantity(), reported_state.filled_quantity(), reported_state.avg_price()); _order_services->report_state(reported_state); From dfa3e4a38da461d8765aa81e59c3e17825db4488 Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Thu, 12 Jul 2018 11:38:29 -0400 Subject: [PATCH 04/16] python... --- tools/clientbuild.cmd | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/clientbuild.cmd b/tools/clientbuild.cmd index 05ded4a4f..09788f7e1 100644 --- a/tools/clientbuild.cmd +++ b/tools/clientbuild.cmd @@ -7,5 +7,6 @@ if not exist build\src\lib\libspark.vcxproj ( copy /y tools\cpp.build.props build\Directory.Build.Props > nul @call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\Common7\Tools\VsDevCmd.bat" > nul cd /d %~dp0\.. +set path=%spark_build_python_path%;%path% msbuild /m /p:debugtype=portable /p:platform=x64 /clp:verbosity=minimal /clp:summary /t:restore %* spark_client.sln msbuild /m /p:debugtype=portable /p:platform=x64 /p:GenerateFullPaths=true /clp:verbosity=minimal /clp:summary %* spark_client.sln From 197e68e3575f03b0408981a1af0e45a59820267f Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Mon, 16 Jul 2018 13:35:11 -0400 Subject: [PATCH 05/16] Trigger order UI --- .../Orders/OrderModificationControl.xaml.cs | 2 + .../Orders/OrderTypeVMs/OrderTypeVMFactory.cs | 2 + .../Orders/OrderTypeVMs/TriggerOrderVM.cs | 184 ++++++++++++++++++ .../Order/OrderDetailsPopupControl.xaml | 40 +++- .../view/Spark/Utilities/OrderDataHelper.cs | 14 +- src/lib/api/services/OrderService.proto | 2 + 6 files changed, 242 insertions(+), 2 deletions(-) create mode 100644 src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs diff --git a/src/client/spark/Orders/OrderModificationControl.xaml.cs b/src/client/spark/Orders/OrderModificationControl.xaml.cs index 067e32cf0..4fc2bfdc4 100644 --- a/src/client/spark/Orders/OrderModificationControl.xaml.cs +++ b/src/client/spark/Orders/OrderModificationControl.xaml.cs @@ -24,6 +24,7 @@ namespace mbts.ui.spark { public DataTemplate LeanOrderTemplate { get; set; } public DataTemplate JoinOrderTemplate { get; set; } public DataTemplate TopOrderTemplate { get; set; } + public DataTemplate TriggerOrderTemplate { get; set; } public DataTemplate IcebergOrderTemplate { get; set; } public DataTemplate SpreaderTemplate { get; set; } public DataTemplate BTSStopOrderTemplate { get; set; } @@ -41,6 +42,7 @@ namespace mbts.ui.spark { case CustomOrderDefinition.CustomOneofCase.Lean: return LeanOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Join: return JoinOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Top: return TopOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Trigger: return TriggerOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Iceberg: return IcebergOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Spreader: return SpreaderTemplate; } diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index b9467cc56..7a1543ee7 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -18,6 +18,7 @@ namespace mbts.spark { public static IOrderTypeVM lean(OrdersModel model, IObservable security_source) => new LeanOrderVM(model, security_source); public static IOrderTypeVM join(OrdersModel model, IObservable security_source) => new JoinOrderVM(model, security_source); public static IOrderTypeVM top(OrdersModel model, IObservable security_source) => new TopOrderVM(model, security_source); + public static IOrderTypeVM trigger(OrdersModel model, IObservable security_source) => new TriggerOrderVM(model, security_source); public static IOrderTypeVM iceberg(OrdersModel model, IObservable security_source) => new IcebergOrderVM(model, security_source); public static IOrderTypeVM spreader(OrdersModel model, IObservable security_source) => new SpreaderOrderVM(model, security_source); @@ -35,6 +36,7 @@ namespace mbts.spark { case CustomOneofCase.Lean: return lean(model, security_source); case CustomOneofCase.Join: return join(model, security_source); case CustomOneofCase.Top: return top(model, security_source); + case CustomOneofCase.Trigger: return trigger(model, security_source); case CustomOneofCase.Iceberg: return iceberg(model, security_source); case CustomOneofCase.Spreader: return spreader(model, security_source); default: throw new NotImplementedException(); diff --git a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs new file mode 100644 index 000000000..ddbe0d9d9 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs @@ -0,0 +1,184 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineTriggerOrderProperties + { + public InlineTriggerOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + + trigger_price_type = new InlineUserProperty(TriggerPriceType.LastTradePrice, false); + order_price = new InlineUserProperty(double.NaN, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + + public readonly InlineUserProperty trigger_price_type; + public readonly InlineUserProperty order_price; + } + + class TriggerOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineTriggerOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + public TriggerPriceType trigger_price_type { get; set; } = TriggerPriceType.LastTradePrice; + public double order_price { get; set; } = double.NaN; + + public TriggerOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineTriggerOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public TriggerOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.OnDispatcher() + .Subscribe(s => _security = s), + inline_properties.OnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (p.trigger_price_type.force_override) + { + trigger_price_type = p.trigger_price_type.value; + RaisePropertyChanged(nameof(trigger_price_type)); + } + if (p.order_price.force_override) + { + order_price = p.order_price.value; + RaisePropertyChanged(nameof(order_price)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public IEnumerable trigger_price_types => EnumHelper.get_values(); + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.trigger_order(); + i.TriggerCondition = new TriggerCondition() + { + PriceType = trigger_price_type, + AbsolutePriceTrigger = new AbsolutePriceTrigger() { TriggerQuantity = new TriggerQuantity() } + }; + i.TriggerAction = new TriggerAction() + { + Price = order_price, + SecurityId = _security.Value.Id + }; + child_order.assign_to(i.Child); + value.Trigger = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml index 0e8969a2a..2f5a2572f 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml @@ -335,7 +335,45 @@ /> - + + + + + + + + + + + + + + + + + + + + Trigger Price Type + + Order Price + + Child + + + + diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index 2b6f3940e..398448496 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -32,10 +32,12 @@ namespace mbts.spark.utilities { CustomOrderDefinition.CustomOneofCase.Lean, CustomOrderDefinition.CustomOneofCase.Join, CustomOrderDefinition.CustomOneofCase.Top, + CustomOrderDefinition.CustomOneofCase.Trigger, }, _spreader_types = new[] { CustomOrderDefinition.CustomOneofCase.Spreader, CustomOrderDefinition.CustomOneofCase.Iceberg, - CustomOrderDefinition.CustomOneofCase.TimeBox + CustomOrderDefinition.CustomOneofCase.TimeBox, + CustomOrderDefinition.CustomOneofCase.Trigger, }; readonly string _user; readonly AdminModel _admin_model; @@ -213,6 +215,12 @@ namespace mbts.spark.utilities { Child = custom_order(), TopThreshold = new QuantityMeasure(), Hedge = custom_order(), + }; + public TriggerOrderDefinition trigger_order() => new TriggerOrderDefinition + { + Child = custom_order(), + TriggerCondition = new TriggerCondition(), + TriggerAction = new TriggerAction(), }; @@ -231,6 +239,7 @@ namespace mbts.spark.utilities { case CustomOrderDefinition.CustomOneofCase.Lean: rv.Lean = lean_order(); break; case CustomOrderDefinition.CustomOneofCase.Join: rv.Join = join_order(); break; case CustomOrderDefinition.CustomOneofCase.Top: rv.Top = top_order(); break; + case CustomOrderDefinition.CustomOneofCase.Trigger: rv.Trigger = trigger_order(); break; case CustomOrderDefinition.CustomOneofCase.Spreader: rv.Spreader = spreader_order(); break; } return rv; @@ -250,6 +259,7 @@ namespace mbts.spark.utilities { case CustomOrderDefinition.CustomOneofCase.Lean: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.Orders.lean_order }; case CustomOrderDefinition.CustomOneofCase.Join: return new OrderMetadata { KeyBinding = "J", Color = BTSColors.Orders.join_order }; case CustomOrderDefinition.CustomOneofCase.Top: return new OrderMetadata { KeyBinding = "D", Color = BTSColors.Orders.top_order }; + case CustomOrderDefinition.CustomOneofCase.Trigger: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.top_order }; case CustomOrderDefinition.CustomOneofCase.Spreader: goto default; case CustomOrderDefinition.CustomOneofCase.None: goto default; default: return _default_order_metadata; @@ -267,6 +277,7 @@ namespace mbts.spark.utilities { case OrderState.CustomOneofCase.Lean: return new OrderMetadata { KeyBinding = "L", Color = BTSColors.Orders.lean_order }; case OrderState.CustomOneofCase.Join: return new OrderMetadata { KeyBinding = "J", Color = BTSColors.Orders.join_order }; case OrderState.CustomOneofCase.Top: return new OrderMetadata { KeyBinding = "D", Color = BTSColors.Orders.top_order }; + case OrderState.CustomOneofCase.Trigger: return new OrderMetadata { KeyBinding = "T", Color = BTSColors.Orders.top_order }; case OrderState.CustomOneofCase.Spreader: goto default; case OrderState.CustomOneofCase.None: goto default; default: return _default_order_metadata; @@ -302,6 +313,7 @@ namespace mbts.spark.utilities { case nameof(LeanOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Lean; case nameof(JoinOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Join; case nameof(TopOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Top; + case nameof(TriggerOrderDefinition): return CustomOrderDefinition.CustomOneofCase.Trigger; default: throw new ArgumentException($"Unable to match '{order_type_def?.Descriptor.Name}' to an order definition type"); } } diff --git a/src/lib/api/services/OrderService.proto b/src/lib/api/services/OrderService.proto index 63d15cfea..ba736c9aa 100644 --- a/src/lib/api/services/OrderService.proto +++ b/src/lib/api/services/OrderService.proto @@ -121,6 +121,7 @@ message OrderState { LeanOrderState lean = 18; JoinOrderState join = 19; TopOrderState top = 20; + TriggerOrderState trigger = 21; } } @@ -180,6 +181,7 @@ message TickOrderState {} message LeanOrderState {} message JoinOrderState {} message TopOrderState {} +message TriggerOrderState {} enum OrderStatus { From be8ca67be57f42eaafac29afb8204abf67381300 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 16 Jul 2018 13:39:57 -0400 Subject: [PATCH 06/16] TriggerOrder handling cancelled state better --- .../sparkd/orderman/orders/TriggerOrder.cpp | 94 +++++++++++++------ .../sparkd/orderman/orders/TriggerOrder.h | 21 +++-- 2 files changed, 78 insertions(+), 37 deletions(-) diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.cpp b/src/server/sparkd/orderman/orders/TriggerOrder.cpp index f446c9f1f..1695ad9e4 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.cpp +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -18,17 +18,23 @@ struct TriggerOrder::PImpl { ChildOrder child_order; Book book; // this tells that when the order is placed - // initially, is the trigger price above the + // initially, if the trigger price above the // market (trigger_condition's chosen market) bool trigger_above_market; bool market_observed_once; + bool is_cxled; + bool is_recovered; PImpl() : services(nullptr), order_def(), state(), child_state(), - market_observed_once(false){ + child_order(), + book(), + market_observed_once(false), + is_cxled(false), + is_recovered(false){ } }; @@ -44,9 +50,11 @@ const api::orderman::OrderDefinition& TriggerOrder::definition() const{ } void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, const PreActivationOrderServices& pre_os){ + LOG(OrderMan, Warn, "TriggerOrder::on_init_new key:{} state:{}", + key(),_state); switch (_state){ case State::START: - _preinit(order_def,pre_os); + _create_childorder(order_def,pre_os); break; case State::WAITING_FOR_TRIGGER: case State::STEADY: @@ -57,29 +65,46 @@ void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, break; } } -void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord&, +void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord& rec, const PreActivationOrderServices&){ - // mark it as completed and go to the end + // not reviving from disk for now + LOG(OrderMan, Warn, "TriggerOrder::on_init_recovered key:{} state:{}", + key(),_state); + me->order_def=rec.def(); + me->state=rec.state(); + me->is_recovered=true; } void TriggerOrder::on_activate(Price price, Quantity qty, OrderServices& services, TickToTradeCorID){ + LOG(OrderMan, Warn, "TriggerOrder::on_activate key:{} state:{} price:{} qty:{}", + key(),_state, price, qty); switch (_state){ case State::START: - me->state.set_price(price.value()); - me->state.set_quantity(qty.value()); - services.child_updates.sub(key(), - [this](const OrderStateUpdateEvent& os) - { this->_on_child_order_update (os);}); - services.book_updates.sub(SecurityKey(me->order_def.security_key()), - [this](const BookUpdateEvent& bk_event) - { this->_on_book_update (bk_event);}); + me->services=&services; + if(me->is_recovered){ + _switch_state(State::END); + } + else{ + me->state.set_price(price.value()); + me->state.set_quantity(qty.value()); + services.child_updates.sub(key(), + [this](const OrderStateUpdateEvent& os) + { this->_on_child_order_update (os);}); + services.book_updates.sub(SecurityKey(me->order_def.security_key()), + [this](const BookUpdateEvent& bk_event) + { this->_on_book_update (bk_event);}); + _switch_state(State::WAITING_FOR_TRIGGER); + } break; case State::WAITING_FOR_TRIGGER: - case State::STEADY: - bts_assert(false); + case State::STEADY:{ + std::ostringstream oss; + oss << "TriggerOrder::on_activate key:" << key() << "state:" << _state; + bts_assert_msg(false,oss.str()); break; + } case State::END: break; } @@ -88,6 +113,8 @@ void TriggerOrder::on_activate(Price price, void TriggerOrder::on_update(Price price, Quantity qty, TickToTradeCorID){ + LOG(OrderMan, Info, "TriggerOrder::on_update key:{} state:{} price:{} qty:{}", + key(),_state, price, qty); switch (_state){ case State::START: me->state.set_price(price.value()); @@ -114,6 +141,9 @@ void TriggerOrder::on_crack(TickToTradeCorID){ // not supported } void TriggerOrder::on_cancel(TickToTradeCorID){ + LOG(OrderMan, Info, "TriggerOrder::on_cancel key:{} state:{}", + key(),_state); + me->is_cxled=true; switch (_state){ case State::START: _switch_state(State::END); @@ -125,9 +155,7 @@ void TriggerOrder::on_cancel(TickToTradeCorID){ me->child_order.cancel(); _switch_state(State::END); break; - case State::END: - LOG(OrderMan, Warn, "TriggerOrder::on_cancel key:{} state:{}", - key(),_state); + case State::END: break; } } @@ -164,8 +192,8 @@ void TriggerOrder::_on_child_order_update(const OrderStateUpdateEvent& o_ev){ } } } -void TriggerOrder::_preinit(const api::orderman::OrderDefinition& order_def, - const PreActivationOrderServices& pre_os){ +void TriggerOrder::_create_childorder(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os){ me->order_def=order_def; const auto& trigger_order_def=order_def.custom_def().trigger(); api::orderman::OrderDefinition child_order_def = order_def; @@ -174,9 +202,10 @@ void TriggerOrder::_preinit(const api::orderman::OrderDefinition& order_def, OrderBuilder order_builder=OrderBuilder(key(),child_order_def,pre_os); me->child_order=order_builder.build(); } -void TriggerOrder::_report_state(){ +void TriggerOrder::_report_state(){ bts_assert(me->services!=nullptr); - _compute_state(); + if (!me->is_recovered) + _compute_state(); me->services->report_state(me->state); } void TriggerOrder::_switch_state(State new_state){ @@ -196,27 +225,30 @@ void TriggerOrder::_switch_state(State new_state){ LOG(OrderMan, Info, "TriggerOrder::_report_state key:{} {}->{}", key(), _state,new_state); + _report_state(); _state=new_state; } void TriggerOrder::_analyze_trigger(){ bts_assert(me->market_observed_once); - const md::PriceSize* eff_top=_eff_top(); + const md::PriceSize* obs_md=_observed_market(); double trigger_price=_trigger_price(); - if((me->trigger_above_market && eff_top->price()>=trigger_price) || - (!me->trigger_above_market && eff_top->price()<=trigger_price)){ + if((me->trigger_above_market && obs_md->price()>=trigger_price) || + (!me->trigger_above_market && obs_md->price()<=trigger_price)){ me->child_order.activate(Price(_child_order_price()), Quantity(me->state.quantity())); _switch_state(State::STEADY); } } -api::orderman::OrderStatus TriggerOrder::_status(){ +api::orderman::OrderStatus TriggerOrder::_status() const{ switch(_state){ case State::START: case State::WAITING_FOR_TRIGGER: case State::STEADY: return api::orderman::OrderStatus::ORDER_STATUS_WORKING; case State::END: - return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; + + return me->is_cxled ? api::orderman::OrderStatus::ORDER_STATUS_CANCELED : + api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; default: bts_assert(false); return api::orderman::OrderStatus::ORDER_STATUS_INACTIVE; @@ -230,14 +262,14 @@ void TriggerOrder::_compute_state(){ } void TriggerOrder::_observe_market_once(){ if(!me->market_observed_once){ - const md::PriceSize* eff_top=_eff_top(); - if(eff_top != nullptr && eff_top->size()>0){ + const md::PriceSize* obs_md=_observed_market(); + if(obs_md != nullptr && obs_md->size()>0){ me->market_observed_once=true; - me->trigger_above_market=_trigger_price()>=eff_top->price(); + me->trigger_above_market=_trigger_price()>=obs_md->price(); } } } -const md::PriceSize* TriggerOrder::_eff_top() const{ +const md::PriceSize* TriggerOrder::_observed_market() const{ if(me->order_def.custom_def().trigger().trigger_condition().price_type()== api::orderman::TriggerPriceType::BID){ const auto& rv=me->book.bid()[0]; diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.h b/src/server/sparkd/orderman/orders/TriggerOrder.h index 90f295cc6..365125649 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.h +++ b/src/server/sparkd/orderman/orders/TriggerOrder.h @@ -37,20 +37,29 @@ public: void on_crack(TickToTradeCorID) override; void on_cancel(TickToTradeCorID) override; private: - // callbacks from orders and book + // callbacks from book and child order udpates void _on_book_update(const BookUpdateEvent&); void _on_child_order_update(OrderStateUpdateEvent const&); private: - void _preinit(const api::orderman::OrderDefinition& order_def, - const PreActivationOrderServices& pre_os); - void _report_state(); + // called from init_new + void _create_childorder(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os); + void _report_state(); void _switch_state(State new_state); void _analyze_trigger(); - api::orderman::OrderStatus _status(); + api::orderman::OrderStatus _status() const; void _compute_state(); + // for non trailing trigger prices, we need a + // notion if initially the trigger price + // was over the observed market or not void _observe_market_once(); - const md::PriceSize* _eff_top() const; + // based on the trigger market to watch returns + // a pointer to the market (bid, ask, ltp). If not + // present returns a nullptr + const md::PriceSize* _observed_market() const; + // this is the price of the parent order double _trigger_price() const; + // this is in the trigger action double _child_order_price() const; private: State _state; From e346858516e9262fe98a5cbd9874dfef59e3b32f Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Mon, 16 Jul 2018 18:37:05 -0400 Subject: [PATCH 07/16] 2 things left, completed vs cancelled, and price rounding for equality --- .../orderman/order_factory/OrderFactory.cpp | 3 ++- .../sparkd/orderman/orders/TriggerOrder.cpp | 19 +++++++++++-------- 2 files changed, 13 insertions(+), 9 deletions(-) diff --git a/src/server/sparkd/orderman/order_factory/OrderFactory.cpp b/src/server/sparkd/orderman/order_factory/OrderFactory.cpp index 8a2681cc9..b3a17ac07 100644 --- a/src/server/sparkd/orderman/order_factory/OrderFactory.cpp +++ b/src/server/sparkd/orderman/order_factory/OrderFactory.cpp @@ -16,6 +16,7 @@ #include "server/sparkd/orderman/orders/book_algos/LeanOrder.h" #include "server/sparkd/orderman/orders/book_algos/JoinOrder.h" #include "server/sparkd/orderman/orders/book_algos/TopOrder.h" +#include "server/sparkd/orderman/orders/TriggerOrder.h" #include #include @@ -137,7 +138,7 @@ Order &OrderFactory::allocate(OrderKey k, OrderKey pk, order_ptr.reset (new orderman::TopOrder()); break; case CustomOrderDefinition::kTrigger: - order_ptr.reset (new orderman::TopOrder()); + order_ptr.reset (new orderman::TriggerOrder()); break; case CustomOrderDefinition::CUSTOM_NOT_SET: bts_assert(false); diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.cpp b/src/server/sparkd/orderman/orders/TriggerOrder.cpp index 1695ad9e4..d93879e29 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.cpp +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -15,6 +15,7 @@ struct TriggerOrder::PImpl { api::orderman::OrderDefinition order_def; api::orderman::OrderState state; api::orderman::OrderState child_state; + OrderBuilder order_builder; ChildOrder child_order; Book book; // this tells that when the order is placed @@ -54,7 +55,7 @@ void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, key(),_state); switch (_state){ case State::START: - _create_childorder(order_def,pre_os); + _create_childorder(order_def,pre_os); break; case State::WAITING_FOR_TRIGGER: case State::STEADY: @@ -72,6 +73,8 @@ void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord& rec, key(),_state); me->order_def=rec.def(); me->state=rec.state(); + if (!SpreaderUtils::order_in_terminal_state(me->state.status())) + me->state.set_status(api::orderman::OrderStatus::ORDER_STATUS_CANCELED); me->is_recovered=true; } void TriggerOrder::on_activate(Price price, @@ -83,12 +86,13 @@ void TriggerOrder::on_activate(Price price, switch (_state){ case State::START: me->services=&services; - if(me->is_recovered){ - _switch_state(State::END); - } + if(me->is_recovered) + _switch_state(State::END); else{ me->state.set_price(price.value()); me->state.set_quantity(qty.value()); + me->order_builder.activate(services); + me->child_order=me->order_builder.build(); services.child_updates.sub(key(), [this](const OrderStateUpdateEvent& os) { this->_on_child_order_update (os);}); @@ -199,8 +203,7 @@ void TriggerOrder::_create_childorder(const api::orderman::OrderDefinition& orde api::orderman::OrderDefinition child_order_def = order_def; child_order_def.set_security_key(trigger_order_def.trigger_action().security_id()); child_order_def.mutable_custom_def()->CopyFrom(trigger_order_def.child()); - OrderBuilder order_builder=OrderBuilder(key(),child_order_def,pre_os); - me->child_order=order_builder.build(); + me->order_builder=OrderBuilder(key(),child_order_def,pre_os); } void TriggerOrder::_report_state(){ bts_assert(me->services!=nullptr); @@ -213,7 +216,7 @@ void TriggerOrder::_switch_state(State new_state){ case State::START: break; case State::WAITING_FOR_TRIGGER: - bts_assert(_state=State::START); + bts_assert(_state==State::START); break; case State::STEADY: bts_assert(_state==State::WAITING_FOR_TRIGGER); @@ -225,8 +228,8 @@ void TriggerOrder::_switch_state(State new_state){ LOG(OrderMan, Info, "TriggerOrder::_report_state key:{} {}->{}", key(), _state,new_state); - _report_state(); _state=new_state; + _report_state(); } void TriggerOrder::_analyze_trigger(){ bts_assert(me->market_observed_once); From b2facaecd97eaa7ce75c756ddf0e7308334b7e97 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 17 Jul 2018 19:33:04 -0400 Subject: [PATCH 08/16] polishing TriggerOrder --- .../sparkd/orderman/orders/TriggerOrder.cpp | 87 +++++++++++++------ .../sparkd/orderman/orders/TriggerOrder.h | 6 +- 2 files changed, 63 insertions(+), 30 deletions(-) diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.cpp b/src/server/sparkd/orderman/orders/TriggerOrder.cpp index d93879e29..216ce6b34 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.cpp +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -4,6 +4,7 @@ #include "server/sparkd/orderman/actors/order_manager/OrderBuilder.h" #include "server/sparkd/orderman/events/BookUpdateEvent.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" +#include "lib/domain_model/Security.h" #include #include @@ -13,6 +14,7 @@ namespace orderman{ struct TriggerOrder::PImpl { OrderServices *services; api::orderman::OrderDefinition order_def; + double tick_size; api::orderman::OrderState state; api::orderman::OrderState child_state; OrderBuilder order_builder; @@ -25,6 +27,7 @@ struct TriggerOrder::PImpl { bool market_observed_once; bool is_cxled; bool is_recovered; + bool is_succ_inited; PImpl() : services(nullptr), @@ -35,7 +38,8 @@ struct TriggerOrder::PImpl { book(), market_observed_once(false), is_cxled(false), - is_recovered(false){ + is_recovered(false), + is_succ_inited(false){ } }; @@ -55,7 +59,7 @@ void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, key(),_state); switch (_state){ case State::START: - _create_childorder(order_def,pre_os); + me->is_succ_inited=_on_init_new(order_def,pre_os); break; case State::WAITING_FOR_TRIGGER: case State::STEADY: @@ -67,15 +71,28 @@ void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, } } void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord& rec, - const PreActivationOrderServices&){ - // not reviving from disk for now + const PreActivationOrderServices& pre_os){ LOG(OrderMan, Warn, "TriggerOrder::on_init_recovered key:{} state:{}", key(),_state); - me->order_def=rec.def(); - me->state=rec.state(); - if (!SpreaderUtils::order_in_terminal_state(me->state.status())) - me->state.set_status(api::orderman::OrderStatus::ORDER_STATUS_CANCELED); - me->is_recovered=true; + switch (_state){ + case State::START: + me->is_succ_inited=_on_init_new(rec.def(),pre_os); + // get the state from what was recovered (we will only use + // it for reporting) + me->state=rec.state(); + // if it was not in a terminal state, we will call it cancelled + if (!SpreaderUtils::order_in_terminal_state(me->state.status())) + me->state.set_status(api::orderman::OrderStatus::ORDER_STATUS_CANCELED); + me->is_recovered=true; + break; + case State::WAITING_FOR_TRIGGER: + case State::STEADY: + case State::END: + std::ostringstream oss; + oss << "TriggerOrder::on_init_recovered key:" << key() << "state:" << _state; + bts_assert_msg(false, oss.str()); + break; + } } void TriggerOrder::on_activate(Price price, Quantity qty, @@ -86,11 +103,11 @@ void TriggerOrder::on_activate(Price price, switch (_state){ case State::START: me->services=&services; - if(me->is_recovered) + me->state.set_price(price.value()); + me->state.set_quantity(qty.value()); + if(me->is_recovered || !me->is_succ_inited) _switch_state(State::END); else{ - me->state.set_price(price.value()); - me->state.set_quantity(qty.value()); me->order_builder.activate(services); me->child_order=me->order_builder.build(); services.child_updates.sub(key(), @@ -103,14 +120,13 @@ void TriggerOrder::on_activate(Price price, } break; case State::WAITING_FOR_TRIGGER: - case State::STEADY:{ + case State::STEADY: + case State::END:{ std::ostringstream oss; oss << "TriggerOrder::on_activate key:" << key() << "state:" << _state; bts_assert_msg(false,oss.str()); break; } - case State::END: - break; } } // order price, qty change @@ -196,20 +212,28 @@ void TriggerOrder::_on_child_order_update(const OrderStateUpdateEvent& o_ev){ } } } -void TriggerOrder::_create_childorder(const api::orderman::OrderDefinition& order_def, - const PreActivationOrderServices& pre_os){ +bool TriggerOrder::_on_init_new(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os){ me->order_def=order_def; const auto& trigger_order_def=order_def.custom_def().trigger(); api::orderman::OrderDefinition child_order_def = order_def; child_order_def.set_security_key(trigger_order_def.trigger_action().security_id()); child_order_def.mutable_custom_def()->CopyFrom(trigger_order_def.child()); me->order_builder=OrderBuilder(key(),child_order_def,pre_os); + const auto* sec_ptr = pre_os.sec_db.resolve(SecurityKey(order_def.security_key())); + if(sec_ptr!=nullptr){ + me->tick_size=std::min(sec_ptr->contract_spec().low_tick(), + sec_ptr->contract_spec().high_tick()); + return true; + } + else + return false; } -void TriggerOrder::_report_state(){ - bts_assert(me->services!=nullptr); - if (!me->is_recovered) +void TriggerOrder::_report_state(){ + if(_activated()){ _compute_state(); - me->services->report_state(me->state); + me->services->report_state(me->state); + } } void TriggerOrder::_switch_state(State new_state){ switch(new_state){ @@ -235,8 +259,8 @@ void TriggerOrder::_analyze_trigger(){ bts_assert(me->market_observed_once); const md::PriceSize* obs_md=_observed_market(); double trigger_price=_trigger_price(); - if((me->trigger_above_market && obs_md->price()>=trigger_price) || - (!me->trigger_above_market && obs_md->price()<=trigger_price)){ + if((me->trigger_above_market && _gr_than_eq(obs_md->price(),trigger_price)) || + (!me->trigger_above_market && _gr_than_eq(trigger_price,obs_md->price()))){ me->child_order.activate(Price(_child_order_price()), Quantity(me->state.quantity())); _switch_state(State::STEADY); @@ -249,7 +273,6 @@ api::orderman::OrderStatus TriggerOrder::_status() const{ case State::STEADY: return api::orderman::OrderStatus::ORDER_STATUS_WORKING; case State::END: - return me->is_cxled ? api::orderman::OrderStatus::ORDER_STATUS_CANCELED : api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; default: @@ -258,10 +281,12 @@ api::orderman::OrderStatus TriggerOrder::_status() const{ } } void TriggerOrder::_compute_state(){ - me->state.set_status(_status()); - me->state.set_filled_quantity(me->child_state.filled_quantity()); - me->state.set_last_price(me->child_state.last_price()); - me->state.set_avg_price(me->child_state.avg_price()); + if (!me->is_recovered){ + me->state.set_status(_status()); + me->state.set_filled_quantity(me->child_state.filled_quantity()); + me->state.set_last_price(me->child_state.last_price()); + me->state.set_avg_price(me->child_state.avg_price()); + } } void TriggerOrder::_observe_market_once(){ if(!me->market_observed_once){ @@ -294,4 +319,10 @@ double TriggerOrder::_trigger_price() const{ double TriggerOrder::_child_order_price() const{ return me->order_def.custom_def().trigger().trigger_action().price(); } +bool TriggerOrder::_activated() const{ + return me->services!=nullptr; +} +bool TriggerOrder::_gr_than_eq(double p1, double p2) const{ + return bts::securities::test_price_equality(p1,p2,me->tick_size) || p1>=p2; +} }} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.h b/src/server/sparkd/orderman/orders/TriggerOrder.h index 365125649..b32a6e56e 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.h +++ b/src/server/sparkd/orderman/orders/TriggerOrder.h @@ -42,8 +42,8 @@ private: void _on_child_order_update(OrderStateUpdateEvent const&); private: // called from init_new - void _create_childorder(const api::orderman::OrderDefinition& order_def, - const PreActivationOrderServices& pre_os); + bool _on_init_new(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pre_os); void _report_state(); void _switch_state(State new_state); void _analyze_trigger(); @@ -61,6 +61,8 @@ private: double _trigger_price() const; // this is in the trigger action double _child_order_price() const; + bool _activated() const; + bool _gr_than_eq(double p1, double p2) const; private: State _state; struct PImpl; From 28a122aa7a8ce2db12f9577f9f618e1e29d334a4 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Tue, 17 Jul 2018 23:50:31 -0400 Subject: [PATCH 09/16] TriggerOrder completed --- .../sparkd/orderman/orders/TriggerOrder.cpp | 20 ++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.cpp b/src/server/sparkd/orderman/orders/TriggerOrder.cpp index 216ce6b34..940fe7b82 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.cpp +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -55,7 +55,7 @@ const api::orderman::OrderDefinition& TriggerOrder::definition() const{ } void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, const PreActivationOrderServices& pre_os){ - LOG(OrderMan, Warn, "TriggerOrder::on_init_new key:{} state:{}", + LOG(OrderMan, Info, "TriggerOrder::on_init_new key:{} state:{}", key(),_state); switch (_state){ case State::START: @@ -72,7 +72,7 @@ void TriggerOrder::on_init_new(const api::orderman::OrderDefinition& order_def, } void TriggerOrder::on_init_recovered(const api::orderman::OrderRecord& rec, const PreActivationOrderServices& pre_os){ - LOG(OrderMan, Warn, "TriggerOrder::on_init_recovered key:{} state:{}", + LOG(OrderMan, Info, "TriggerOrder::on_init_recovered key:{} state:{}", key(),_state); switch (_state){ case State::START: @@ -98,7 +98,7 @@ void TriggerOrder::on_activate(Price price, Quantity qty, OrderServices& services, TickToTradeCorID){ - LOG(OrderMan, Warn, "TriggerOrder::on_activate key:{} state:{} price:{} qty:{}", + LOG(OrderMan, Info, "TriggerOrder::on_activate key:{} state:{} price:{} qty:{}", key(),_state, price, qty); switch (_state){ case State::START: @@ -139,7 +139,7 @@ void TriggerOrder::on_update(Price price, case State::START: me->state.set_price(price.value()); me->state.set_quantity(qty.value()); - _report_state(); + // cant report because does not have order_services yet break; case State::WAITING_FOR_TRIGGER: me->state.set_price(price.value()); @@ -222,8 +222,10 @@ bool TriggerOrder::_on_init_new(const api::orderman::OrderDefinition& order_def, me->order_builder=OrderBuilder(key(),child_order_def,pre_os); const auto* sec_ptr = pre_os.sec_db.resolve(SecurityKey(order_def.security_key())); if(sec_ptr!=nullptr){ + LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} could not resolve seckey:{}", + key(),_state,order_def.security_key()); me->tick_size=std::min(sec_ptr->contract_spec().low_tick(), - sec_ptr->contract_spec().high_tick()); + sec_ptr->contract_spec().high_tick()); return true; } else @@ -268,13 +270,17 @@ void TriggerOrder::_analyze_trigger(){ } api::orderman::OrderStatus TriggerOrder::_status() const{ switch(_state){ + // will only be called once the order + // has been activated case State::START: case State::WAITING_FOR_TRIGGER: case State::STEADY: return api::orderman::OrderStatus::ORDER_STATUS_WORKING; case State::END: - return me->is_cxled ? api::orderman::OrderStatus::ORDER_STATUS_CANCELED : - api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; + return (me->is_cxled || + SpreaderUtils::order_in_cancelled_state(me->child_state.status())) ? + api::orderman::OrderStatus::ORDER_STATUS_CANCELED : + api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; default: bts_assert(false); return api::orderman::OrderStatus::ORDER_STATUS_INACTIVE; From 570dd387d20b30039802c2dd0638fb641ee9f21a Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Wed, 18 Jul 2018 12:34:41 -0400 Subject: [PATCH 10/16] MDConsumer::get_handle() needs to check if the handle is a synthetic --- src/lib/md/MDConsumer.cpp | 15 +++++++++++++++ src/lib/md/MDConsumerHandle.h | 2 +- 2 files changed, 16 insertions(+), 1 deletion(-) diff --git a/src/lib/md/MDConsumer.cpp b/src/lib/md/MDConsumer.cpp index be06acd4a..1fb1a5995 100644 --- a/src/lib/md/MDConsumer.cpp +++ b/src/lib/md/MDConsumer.cpp @@ -352,6 +352,14 @@ class SyntheticConsumerInst { return result; } + const ItemType get_synthetic(security_key key) const { + const auto result = _data.find(key); + if (result != _data.end()) { + return result->second; + } + return nullptr; + } + const vector scan_new_synthetics() { Mutex::scoped_lock lock(_workmutex); init(); @@ -566,6 +574,12 @@ public: } MDConsumerHandle get_handle(security_key key) { + // Check synthetics first because it's fast. + if (_sci) { + auto handle = _sci->get_synthetic(key); + if (handle) return MDConsumerHandle(handle); + } + const void* hot = nullptr; const ColdEntry* cold = nullptr; // Search through the instances for one that has this handle @@ -576,6 +590,7 @@ public: return handle; } } + // If we can't find it return an empty handle. This handle could be later initialized when the security is available. MDConsumerHandle empty_handle; return empty_handle; diff --git a/src/lib/md/MDConsumerHandle.h b/src/lib/md/MDConsumerHandle.h index ccf16018e..6c360cd55 100644 --- a/src/lib/md/MDConsumerHandle.h +++ b/src/lib/md/MDConsumerHandle.h @@ -34,7 +34,7 @@ class BTS_EXPORT MDConsumerHandle { public: MDConsumerHandle(); - MDConsumerHandle(const std::shared_ptr&); + explicit MDConsumerHandle(const std::shared_ptr&); ~MDConsumerHandle(); MDConsumerHandle(const MDConsumerHandle& other); From 52001a55c62d2300cd7c60680a35502091e2c738 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Wed, 18 Jul 2018 13:25:29 -0400 Subject: [PATCH 11/16] MDConsumer::get_handle() needs to process async work before searching handles --- src/lib/md/MDConsumer.cpp | 40 ++++++++++++++++++++++----------------- 1 file changed, 23 insertions(+), 17 deletions(-) diff --git a/src/lib/md/MDConsumer.cpp b/src/lib/md/MDConsumer.cpp index 1fb1a5995..c6bc7eb3f 100644 --- a/src/lib/md/MDConsumer.cpp +++ b/src/lib/md/MDConsumer.cpp @@ -298,15 +298,16 @@ private: class SyntheticConsumerInst { typedef tbb::queuing_mutex Mutex; typedef function(const set&)> IGetHandle; - typedef shared_ptr ItemType; + typedef shared_ptr StrategyPtr; struct IncompleteStrategy { shared_ptr security; spark::ExecutionStrategy strategy; }; + // LOCK only public methods Mutex _workmutex; shared_ptr _ss; - map _data; + map _data; vector> _pending; set _seen; IGetHandle _get_handle; @@ -341,9 +342,9 @@ class SyntheticConsumerInst { return _ss->securities().size(); } - const vector get_old_synthetics() { + const vector get_old_synthetics() { Mutex::scoped_lock lock(_workmutex); - vector result; + vector result; for (const auto& i : _data) { if (_seen.find(i.first) != _seen.end()) { result.push_back(i.second); @@ -352,7 +353,9 @@ class SyntheticConsumerInst { return result; } - const ItemType get_synthetic(security_key key) const { + const StrategyPtr get_synthetic(security_key key) { + Mutex::scoped_lock lock(_workmutex); + process_pending(); const auto result = _data.find(key); if (result != _data.end()) { return result->second; @@ -360,15 +363,10 @@ class SyntheticConsumerInst { return nullptr; } - const vector scan_new_synthetics() { + const vector scan_new_synthetics() { Mutex::scoped_lock lock(_workmutex); - init(); - if (!_pending.empty()) { - vector> temp; - temp.swap(_pending); - add_snapshot(temp); - } - vector result; + process_pending(); + vector result; for (const auto& i : _data) { if (_seen.find(i.first) == _seen.end()) { result.push_back(i.second); @@ -379,6 +377,15 @@ class SyntheticConsumerInst { } private: + void process_pending() { + init(); + if (!_pending.empty()) { + vector> temp; + temp.swap(_pending); + add_snapshot(temp); + } + } + void init() { if (!_initialized) { _initialized = true; @@ -418,9 +425,9 @@ private: } private: - static map get_synthetic_handles( + static map get_synthetic_handles( vector synthetics, - const map& existing, + const map& existing, const std::function(const set&)>& get_handles) { // gather leg keys for batch processing @@ -434,7 +441,7 @@ private: auto real_handles = get_handles(leg_keys); // result will be merged with _data - map result; + map result; size_t result_count; do { result_count = result.size(); @@ -510,7 +517,6 @@ private: } } - }; /////////////////////////////////////////////////////////////////////////////////////////////////// From 4d99ffc86c99767ab548478d2dabd948236d32b2 Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Wed, 18 Jul 2018 15:21:00 -0400 Subject: [PATCH 12/16] SPARK-1464 I couldn't get the order price to default to the bid, but sending to John --- .../Orders/OrderTypeVMs/TriggerOrderVM.cs | 18 ++++++++++++++---- .../Order/OrderDetailsPopupControl.xaml | 2 +- 2 files changed, 15 insertions(+), 5 deletions(-) diff --git a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs index ddbe0d9d9..9f3f91928 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs @@ -23,8 +23,8 @@ namespace mbts.spark this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); this.child_order_types = new InlineUserProperty>(child_order_types, true); - trigger_price_type = new InlineUserProperty(TriggerPriceType.LastTradePrice, false); - order_price = new InlineUserProperty(double.NaN, false); + trigger_price_type = new InlineUserProperty(TriggerPriceType.Bid, false); + order_price = new InlineUserProperty(double.NaN, true); } public readonly InlineUserProperty selected_child_order_type; public readonly InlineUserProperty> child_order_types; @@ -43,7 +43,7 @@ namespace mbts.spark IOrderTypeVM _child_order; IDisposable _dispose, _child_order_errors_sub; - public TriggerPriceType trigger_price_type { get; set; } = TriggerPriceType.LastTradePrice; + public TriggerPriceType trigger_price_type { get; set; } = TriggerPriceType.Bid; public double order_price { get; set; } = double.NaN; public TriggerOrderVM(OrdersModel model, IObservable security_source) @@ -84,7 +84,7 @@ namespace mbts.spark _validate(); } - public IEnumerable trigger_price_types => EnumHelper.get_values(); + public IEnumerable trigger_price_types => EnumHelper.get_values_except(TriggerPriceType.LastTradePrice); public override void assign_to(CustomOrderDefinition value) { @@ -108,6 +108,16 @@ namespace mbts.spark value.Trigger = i; } } + + public double price_tick + { + get { return _security.Value.ContractSpec.LowTick; } + } + + public ContractSpecificationImmutable spec + { + get { return _security.Value.ContractSpec; } + } public ICollection child_order_types { diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml index 2f5a2572f..0fb815cbe 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml @@ -362,7 +362,7 @@ SelectedItem="{Binding trigger_price_type}" /> Order Price - + Child Date: Wed, 18 Jul 2018 12:38:55 -0400 Subject: [PATCH 13/16] TriggerOrder incorrect assertion --- .../sparkd/orderman/orders/TriggerOrder.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.cpp b/src/server/sparkd/orderman/orders/TriggerOrder.cpp index 940fe7b82..61e3b3134 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.cpp +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -185,8 +185,7 @@ void TriggerOrder::_on_book_update(const BookUpdateEvent& b_event){ if(b_event.key().value()==me->order_def.security_key()){ me->book=b_event.book; _observe_market_once(); - if(me->market_observed_once) - _analyze_trigger(); + _analyze_trigger(); } break; case State::START: @@ -258,14 +257,15 @@ void TriggerOrder::_switch_state(State new_state){ _report_state(); } void TriggerOrder::_analyze_trigger(){ - bts_assert(me->market_observed_once); - const md::PriceSize* obs_md=_observed_market(); - double trigger_price=_trigger_price(); - if((me->trigger_above_market && _gr_than_eq(obs_md->price(),trigger_price)) || - (!me->trigger_above_market && _gr_than_eq(trigger_price,obs_md->price()))){ - me->child_order.activate(Price(_child_order_price()), + if(me->market_observed_once){ + double trigger_price=_trigger_price(); + const md::PriceSize* obs_md=_observed_market(); + if((me->trigger_above_market && _gr_than_eq(obs_md->price(),trigger_price)) || + (!me->trigger_above_market && _gr_than_eq(trigger_price,obs_md->price()))){ + me->child_order.activate(Price(_child_order_price()), Quantity(me->state.quantity())); - _switch_state(State::STEADY); + _switch_state(State::STEADY); + } } } api::orderman::OrderStatus TriggerOrder::_status() const{ From b692742e302fb97349f4447b4a1af606658fe38a Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 18 Jul 2018 17:28:42 -0400 Subject: [PATCH 14/16] better error messages for TriggerOrder --- .../sparkd/orderman/orders/TriggerOrder.cpp | 56 ++++++++++++++----- 1 file changed, 41 insertions(+), 15 deletions(-) diff --git a/src/server/sparkd/orderman/orders/TriggerOrder.cpp b/src/server/sparkd/orderman/orders/TriggerOrder.cpp index 61e3b3134..c5d1d2721 100644 --- a/src/server/sparkd/orderman/orders/TriggerOrder.cpp +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -5,6 +5,7 @@ #include "server/sparkd/orderman/events/BookUpdateEvent.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderUtils.h" #include "lib/domain_model/Security.h" +#include "lib/os/os.h" #include #include @@ -148,7 +149,7 @@ void TriggerOrder::on_update(Price price, _analyze_trigger(); break; case State::STEADY: - // can not change it, send out a text msg + me->state.set_last_msg("Trigger order can not be modified after the trigger has been hit"); _report_state(); break; case State::END: @@ -214,21 +215,43 @@ void TriggerOrder::_on_child_order_update(const OrderStateUpdateEvent& o_ev){ bool TriggerOrder::_on_init_new(const api::orderman::OrderDefinition& order_def, const PreActivationOrderServices& pre_os){ me->order_def=order_def; + if (!me->order_def.has_custom_def() || !me->order_def.custom_def().has_trigger()){ + LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " + "OrderDefinition does not have TriggerOrderDefinition", + key(),_state); + me->state.set_last_msg("Trigger Order not properly formed"); + return false; + } + if (pre_os.sec_db.resolve(SecurityKey(order_def.security_key()))==nullptr){ + LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " + "Could not resolve sec_key:{}", + key(),_state, order_def.security_key()); + me->state.set_last_msg("Could not resolve Trigger Order security"); + return false; + } const auto& trigger_order_def=order_def.custom_def().trigger(); + if(pre_os.sec_db.resolve(SecurityKey(trigger_order_def.trigger_action().security_id())) == nullptr){ + LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " + "Could not resolve child key sec_key:{}", + key(),_state, trigger_order_def.trigger_action().security_id()); + me->state.set_last_msg("Could not resolve Trigger Order child security"); + return false; + } + if (bts::os::is_nan(trigger_order_def.trigger_action().price())){ + LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} " + "illegal child order price", + key(),_state); + me->state.set_last_msg("Illegal Child Order price"); + return false; + } api::orderman::OrderDefinition child_order_def = order_def; child_order_def.set_security_key(trigger_order_def.trigger_action().security_id()); child_order_def.mutable_custom_def()->CopyFrom(trigger_order_def.child()); me->order_builder=OrderBuilder(key(),child_order_def,pre_os); const auto* sec_ptr = pre_os.sec_db.resolve(SecurityKey(order_def.security_key())); - if(sec_ptr!=nullptr){ - LOG(OrderMan, Error, "TriggerOrder::_on_init_new key:{} state:{} could not resolve seckey:{}", - key(),_state,order_def.security_key()); - me->tick_size=std::min(sec_ptr->contract_spec().low_tick(), - sec_ptr->contract_spec().high_tick()); - return true; - } - else - return false; + me->tick_size=std::min(sec_ptr->contract_spec().low_tick(), + sec_ptr->contract_spec().high_tick()); + return true; } void TriggerOrder::_report_state(){ if(_activated()){ @@ -276,11 +299,14 @@ api::orderman::OrderStatus TriggerOrder::_status() const{ case State::WAITING_FOR_TRIGGER: case State::STEADY: return api::orderman::OrderStatus::ORDER_STATUS_WORKING; - case State::END: - return (me->is_cxled || - SpreaderUtils::order_in_cancelled_state(me->child_state.status())) ? - api::orderman::OrderStatus::ORDER_STATUS_CANCELED : - api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; + case State::END: + if(me->is_cxled || + SpreaderUtils::order_in_cancelled_state(me->child_state.status())) + return api::orderman::OrderStatus::ORDER_STATUS_CANCELED; + else if(!me->is_succ_inited) + return api::orderman::OrderStatus::ORDER_STATUS_ERROR; + else + return api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; default: bts_assert(false); return api::orderman::OrderStatus::ORDER_STATUS_INACTIVE; From a9ee246436f720d49f1fd8075f82cc140e18a3ee Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Wed, 18 Jul 2018 18:05:48 -0400 Subject: [PATCH 15/16] Share MDConsumer between MDSource and SecuritySrc. Fixes problem with synthetics when nobody calls scan_securities() to do security discovery --- src/lib/md/MDConsumer.cpp | 14 ++++----- src/server/sparkd/orderman/actors/MDSource.h | 29 ++++++++++--------- .../sparkd/orderman/actors/SecuritySrc.cpp | 8 ++--- .../sparkd/orderman/actors/SecuritySrc.h | 3 +- .../orderman/server/OrderServiceServer.cpp | 14 +++++---- 5 files changed, 37 insertions(+), 31 deletions(-) diff --git a/src/lib/md/MDConsumer.cpp b/src/lib/md/MDConsumer.cpp index c6bc7eb3f..1cc67dd08 100644 --- a/src/lib/md/MDConsumer.cpp +++ b/src/lib/md/MDConsumer.cpp @@ -355,7 +355,6 @@ class SyntheticConsumerInst { const StrategyPtr get_synthetic(security_key key) { Mutex::scoped_lock lock(_workmutex); - process_pending(); const auto result = _data.find(key); if (result != _data.end()) { return result->second; @@ -365,7 +364,12 @@ class SyntheticConsumerInst { const vector scan_new_synthetics() { Mutex::scoped_lock lock(_workmutex); - process_pending(); + init(); + if (!_pending.empty()) { + vector> temp; + temp.swap(_pending); + add_snapshot(temp); + } vector result; for (const auto& i : _data) { if (_seen.find(i.first) == _seen.end()) { @@ -378,12 +382,6 @@ class SyntheticConsumerInst { private: void process_pending() { - init(); - if (!_pending.empty()) { - vector> temp; - temp.swap(_pending); - add_snapshot(temp); - } } void init() { diff --git a/src/server/sparkd/orderman/actors/MDSource.h b/src/server/sparkd/orderman/actors/MDSource.h index 4bec8e7b3..8af789f48 100644 --- a/src/server/sparkd/orderman/actors/MDSource.h +++ b/src/server/sparkd/orderman/actors/MDSource.h @@ -2,7 +2,7 @@ #include "lib/logging/logging.h" #include "lib/md/MDConsumerHandle.h" -#include "lib/md/MDRecoverableConsumer.h" +#include "lib/md/MDConsumer.h" #include "lib/utils/TimeStamp.h" #include "server/sparkd/mercury/actors/Actor.h" #include "server/sparkd/mercury/events/TimerEvent.h" @@ -21,11 +21,10 @@ namespace orderman { class MDSource : public mercury::Actor, public mercury::IPollableActor { public: - MDSource(std::shared_ptr& ss): + MDSource(md::MDConsumer& consumer): _handles(), - _md_consumer(ss), - _book_update(), - _keep_alive() + _md_consumer(consumer), + _book_update() {} void init() override { LOG(OrderMan, Warn, "Starting MDSource actor"); @@ -37,7 +36,7 @@ class MDSource : public mercury::Actor, public mercury::IPollableActor { auto k = ev.security_key.value(); for (auto &h : _handles) - if (h.handle->key() == k) { + if (h.handle.key() == k) { // we want to resend this MD so that late joiners can // catch up h.last = utils::TimeStamp(); @@ -46,9 +45,8 @@ class MDSource : public mercury::Actor, public mercury::IPollableActor { LOG(OrderMan, Warn, "Starting to publish book updates for security key: {}", k); - auto managed_handle = _md_consumer.get_managed_handle(k); - _keep_alive.push_back(managed_handle); - _handles.push_back({utils::TimeStamp(), managed_handle.get()}); + auto handle = _md_consumer.get_handle(k); + _handles.push_back({utils::TimeStamp(), handle}); } }); } @@ -60,12 +58,18 @@ class MDSource : public mercury::Actor, public mercury::IPollableActor { for (auto &h : _handles) { auto &handle = h.handle; - if (handle->get_depth(h.last, std::tuple_size(), + if (handle.get_depth(h.last, std::tuple_size(), &book.bid()[0], &book.ask()[0]) == md::HandleReadResult::SUCCESS) { +<<<<<<< HEAD book._security_key = SecurityKey(handle->key()); corid = cid::make_md_cid(handle->sequence()); tracepoint (bts_trace,trace_order,(char*) "MDSource", 0, corid,0); +======= + book._security_key = SecurityKey(handle.key()); + corid = handle.sequence(); + tracepoint (bts_trace,trace_order,(char*) "MDSource", 0, corid); +>>>>>>> Share MDConsumer between MDSource and SecuritySrc. Fixes problem with synthetics when nobody calls scan_securities() to do security discovery publish(_book_update, book, corid); } } @@ -73,13 +77,12 @@ class MDSource : public mercury::Actor, public mercury::IPollableActor { struct HandleRecord { utils::TimeStamp last; - md::MDConsumerHandle *handle; + md::MDConsumerHandle handle; }; std::vector _handles; - md::MDRecoverableConsumer _md_consumer; + md::MDConsumer _md_consumer; mercury::Stream _book_update; - std::vector> _keep_alive; }; } } diff --git a/src/server/sparkd/orderman/actors/SecuritySrc.cpp b/src/server/sparkd/orderman/actors/SecuritySrc.cpp index 79a11d1c8..5237cd0e3 100644 --- a/src/server/sparkd/orderman/actors/SecuritySrc.cpp +++ b/src/server/sparkd/orderman/actors/SecuritySrc.cpp @@ -1,5 +1,5 @@ #include "SecuritySrc.h" -#include "lib/md/MDRecoverableConsumer.h" +#include "lib/md/MDConsumer.h" #include "lib/utils/bts_chrono.h" #include "server/sparkd/mercury/events/TimerEvent.h" #include "server/sparkd/orderman/events/NewSecuritiesEvent.h" @@ -10,15 +10,15 @@ namespace bts { namespace orderman { struct SecuritySrc::PImpl { - PImpl(std::shared_ptr& ss) : md_consumer(ss) {} + PImpl(md::MDConsumer& md) : md_consumer(md) {} TimeStamp last_scan; mercury::Stream new_securities_stream; std::vector to_publish; - md::MDRecoverableConsumer md_consumer; + md::MDConsumer md_consumer; std::vector> securities_keep_alive; }; -SecuritySrc::SecuritySrc(std::shared_ptr& ss) : me(new PImpl(ss)) {} +SecuritySrc::SecuritySrc(md::MDConsumer& md) : me(new PImpl(md)) {} SecuritySrc::~SecuritySrc() {} void SecuritySrc::init() { diff --git a/src/server/sparkd/orderman/actors/SecuritySrc.h b/src/server/sparkd/orderman/actors/SecuritySrc.h index 4b16ba42a..30cbece29 100644 --- a/src/server/sparkd/orderman/actors/SecuritySrc.h +++ b/src/server/sparkd/orderman/actors/SecuritySrc.h @@ -4,13 +4,14 @@ #include "server/sparkd/mercury/actors/Actor.h" namespace bts { +namespace md { class MDConsumer; } namespace api { class Security; class ISyntheticSecurityService; } namespace orderman { class SecuritySrc : public mercury::Actor { public: - SecuritySrc(std::shared_ptr& ss); + SecuritySrc(md::MDConsumer&); ~SecuritySrc(); void init() override; diff --git a/src/server/sparkd/orderman/server/OrderServiceServer.cpp b/src/server/sparkd/orderman/server/OrderServiceServer.cpp index 332a84f0d..cf80d26f5 100644 --- a/src/server/sparkd/orderman/server/OrderServiceServer.cpp +++ b/src/server/sparkd/orderman/server/OrderServiceServer.cpp @@ -15,18 +15,20 @@ #include "server/sparkd/orderman/actors/SecuritySrc.h" #include "server/sparkd/orderman/actors/ServiceBridge.h" #include "server/sparkd/orderman/actors/order_manager/OrderManager.h" +#include "lib/md/MDConsumer.h" namespace bts { namespace orderman { struct OrderServiceServer::PImpl { - PImpl(bts::api::ServiceContext &ctx) + PImpl(bts::api::ServiceContext &ctx, std::shared_ptr& ss) : fast_broker(std::make_shared()), slow_broker(std::make_shared()), service_bridge(), fast_exe(*fast_broker), slow_exe(*slow_broker), fast_thread(), slow_thread(), service_ready(false), known_orders(), known_fills(), publish_orders(), publish_fills(), - admin_service(ctx.locate()) {} + admin_service(ctx.locate()), + md_consumer(ss) {} std::shared_ptr fast_broker; std::shared_ptr slow_broker; @@ -42,12 +44,14 @@ struct OrderServiceServer::PImpl { OrderServiceServer::OrdersPublisher publish_orders; OrderServiceServer::FillsPublisher publish_fills; api::admin::AdminService admin_service; + bts::md::MDConsumer md_consumer; }; OrderServiceServer::OrderServiceServer( bts::api::ServiceContext &ctx, std::shared_ptr &ss) - : api::orderman::OrderServiceBase(ctx), me(new PImpl(ctx)) { + : api::orderman::OrderServiceBase(ctx), me(new PImpl(ctx, ss)) { + me->publish_orders = make_orders_publisher(); me->publish_fills = make_fills_publisher(); @@ -66,7 +70,7 @@ OrderServiceServer::OrderServiceServer( me->slow_broker->init_neighbours({me->fast_broker}); // fast actors - me->fast_exe.spawn(ss); + me->fast_exe.spawn(me->md_consumer); me->fast_exe.spawn(); auto &all_connections = config::get().connection(); @@ -85,7 +89,7 @@ OrderServiceServer::OrderServiceServer( me->slow_exe.spawn(); me->slow_exe.spawn(); me->slow_exe.spawn(); - me->slow_exe.spawn(ss); + me->slow_exe.spawn(me->md_consumer); me->slow_thread = std::thread([this]() { os::set_thread_name("slow_exe"); for (;;) From 974be037fe23397a54d9afd63902afe24800de42 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Thu, 19 Jul 2018 11:23:56 -0400 Subject: [PATCH 16/16] forgot pushing this merge in --- src/server/sparkd/orderman/actors/MDSource.h | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/src/server/sparkd/orderman/actors/MDSource.h b/src/server/sparkd/orderman/actors/MDSource.h index 8af789f48..a4d293d7d 100644 --- a/src/server/sparkd/orderman/actors/MDSource.h +++ b/src/server/sparkd/orderman/actors/MDSource.h @@ -60,16 +60,10 @@ class MDSource : public mercury::Actor, public mercury::IPollableActor { auto &handle = h.handle; if (handle.get_depth(h.last, std::tuple_size(), &book.bid()[0], &book.ask()[0]) == - md::HandleReadResult::SUCCESS) { -<<<<<<< HEAD - book._security_key = SecurityKey(handle->key()); - corid = cid::make_md_cid(handle->sequence()); - tracepoint (bts_trace,trace_order,(char*) "MDSource", 0, corid,0); -======= + md::HandleReadResult::SUCCESS) { book._security_key = SecurityKey(handle.key()); - corid = handle.sequence(); - tracepoint (bts_trace,trace_order,(char*) "MDSource", 0, corid); ->>>>>>> Share MDConsumer between MDSource and SecuritySrc. Fixes problem with synthetics when nobody calls scan_securities() to do security discovery + corid = cid::make_md_cid(handle.sequence()); + tracepoint (bts_trace,trace_order,(char*) "MDSource", 0, corid,0); publish(_book_update, book, corid); } }