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..9f3f91928 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs @@ -0,0 +1,194 @@ +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.Bid, false); + order_price = new InlineUserProperty(double.NaN, true); + } + 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.Bid; + 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_except(TriggerPriceType.LastTradePrice); + + 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 double price_tick + { + get { return _security.Value.ContractSpec.LowTick; } + } + + public ContractSpecificationImmutable spec + { + get { return _security.Value.ContractSpec; } + } + + 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..0fb815cbe 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 065095fcd..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"); } } @@ -311,8 +323,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 dc44b5e68..46db8373b 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; } } @@ -84,6 +85,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]; @@ -119,6 +121,7 @@ message OrderState { LeanOrderState lean = 18; JoinOrderState join = 19; TopOrderState top = 20; + TriggerOrderState trigger = 21; } } @@ -184,6 +187,7 @@ message TickOrderState {} message LeanOrderState {} message JoinOrderState {} message TopOrderState {} +message TriggerOrderState {} enum OrderStatus { @@ -325,3 +329,46 @@ 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{ + // we can leave out qty for now + TriggerQuantity trigger_quantity = 10; +} +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 orderprice{ + TriggerPayupPrice payup = 20; + double price = 30; + } +} \ No newline at end of file diff --git a/src/lib/md/MDConsumer.cpp b/src/lib/md/MDConsumer.cpp index 19fe8ac23..bb6839abd 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,16 @@ class SyntheticConsumerInst { return result; } - const vector scan_new_synthetics() { + const StrategyPtr get_synthetic(security_key key) { + Mutex::scoped_lock lock(_workmutex); + 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(); if (!_pending.empty()) { @@ -360,7 +370,7 @@ class SyntheticConsumerInst { temp.swap(_pending); add_snapshot(temp); } - vector result; + vector result; for (const auto& i : _data) { if (_seen.find(i.first) == _seen.end()) { result.push_back(i.second); @@ -371,6 +381,9 @@ class SyntheticConsumerInst { } private: + void process_pending() { + } + void init() { if (!_initialized) { _initialized = true; @@ -410,9 +423,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 @@ -426,7 +439,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(); @@ -502,7 +515,6 @@ private: } } - }; /////////////////////////////////////////////////////////////////////////////////////////////////// @@ -566,6 +578,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 +594,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); diff --git a/src/server/sparkd/CMakeDeps.cmake b/src/server/sparkd/CMakeDeps.cmake index f72f5bb4d..c164fdc04 100644 --- a/src/server/sparkd/CMakeDeps.cmake +++ b/src/server/sparkd/CMakeDeps.cmake @@ -1 +1 @@ -set(sources cmds/AutoCert.cpp;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/QuickTest.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Span.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/Web.cpp;dspark/mirage/quick_queue/quick_queue.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/book/Book.cpp;exchange_sim/book/ExchangeSim.proto;exchange_sim/book/Order.cpp;exchange_sim/book/OrderMatcher.cpp;exchange_sim/book/book_transform.cpp;exchange_sim/tests/test_book_transform.cpp;http/ApiGateway.cpp;http/WebServer.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/sample_fix.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;mercury/actors/Actor.cpp;mercury/broker/AsyncEventBroker.cpp;mercury/broker/CoreEventBroker.cpp;mercury/broker/IEventBroker.cpp;mercury/events/TimerEvent.cpp;mercury/mercury_utils/Executor.cpp;mercury/mercury_utils/IPollableActor.cpp;mercury/mercury_utils/mercury_common.cpp;mercury/synopsis/SynopsisBuilder.cpp;mercury/topics/ITopic.cpp;orderman/actors/AsyncFactory.cpp;orderman/actors/ExecutionGateway.cpp;orderman/actors/FillStore.cpp;orderman/actors/OrderStore.cpp;orderman/actors/SecuritySrc.cpp;orderman/actors/ServiceBridge.cpp;orderman/actors/order_manager/OrderBuilder.cpp;orderman/actors/order_manager/OrderManager.cpp;orderman/actors/order_manager/OrderServicesData.cpp;orderman/events/CancelRejectEvent.cpp;orderman/events/NewExecutionReportEvent.cpp;orderman/limiter/LimitStore.cpp;orderman/limiter/Limiter.cpp;orderman/limiter/ProductLimitNode.cpp;orderman/limiter/ProductLimitTree.cpp;orderman/limiter/SecurityLimitNode.cpp;orderman/limiter/SecurityLimitTree.cpp;orderman/limiter/tests/limit_tests.cpp;orderman/order_factory/OrderFactory.cpp;orderman/order_router/OrderRouter.cpp;orderman/orderman_utils/fix_order_codec.cpp;orderman/orders/IcebergOrder.cpp;orderman/orders/NativeOrder.cpp;orderman/orders/Order.cpp;orderman/orders/TimeBoxOrder.cpp;orderman/orders/book_algos/BookAlgo.cpp;orderman/orders/book_algos/JoinOrder.cpp;orderman/orders/book_algos/LeanOrder.cpp;orderman/orders/book_algos/TickOrder.cpp;orderman/orders/book_algos/TopOrder.cpp;orderman/orders/spreader_orders/SpreaderOrder.cpp;orderman/orders/spreader_orders/spreader/LegPropertyData.cpp;orderman/orders/spreader_orders/spreader/QuoteLegPriceQuantityState.cpp;orderman/orders/spreader_orders/spreader/SingleFillHedger.cpp;orderman/orders/spreader_orders/spreader/SingleLegQuoter.cpp;orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp;orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.cpp;orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp;orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp;orderman/orders/spreader_orders/spreader/hedger/UnhedgedDelta.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/QuoteDriverSet.cpp;orderman/orders/spreader_orders/spreader/quoter/QuoteDriverSetHistory.cpp;orderman/orders/spreader_orders/spreader/quoter/QuoteLegDriver.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/orders/spreader_orders/tests/spreader_tests.cpp;orderman/server/OrderServiceServer.cpp;orderman/tests/fat_wrapper_tests.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;position/IMarginObserver.cpp;position/IPositionObserver.cpp;position/MarginServiceCore.cpp;position/PositionServiceCore.cpp;position/tests/PositionTests.cpp;support/ErrorReportService.cpp;support/ShellLatencyServer.cpp;tracing/bts_trace_c.c;user/AdminServiceServer.cpp;user/UserServiceServer.cpp;user/tests/admin_service_tests.cpp) \ No newline at end of file +set(sources cmds/AutoCert.cpp;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/QuickTest.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Span.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;cmds/Web.cpp;dspark/mirage/quick_queue/quick_queue.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/book/Book.cpp;exchange_sim/book/ExchangeSim.proto;exchange_sim/book/Order.cpp;exchange_sim/book/OrderMatcher.cpp;exchange_sim/book/book_transform.cpp;exchange_sim/tests/test_book_transform.cpp;http/ApiGateway.cpp;http/WebServer.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/sample_fix.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;mercury/actors/Actor.cpp;mercury/broker/AsyncEventBroker.cpp;mercury/broker/CoreEventBroker.cpp;mercury/broker/IEventBroker.cpp;mercury/events/TimerEvent.cpp;mercury/mercury_utils/Executor.cpp;mercury/mercury_utils/IPollableActor.cpp;mercury/mercury_utils/mercury_common.cpp;mercury/synopsis/SynopsisBuilder.cpp;mercury/topics/ITopic.cpp;orderman/actors/AsyncFactory.cpp;orderman/actors/ExecutionGateway.cpp;orderman/actors/FillStore.cpp;orderman/actors/OrderStore.cpp;orderman/actors/SecuritySrc.cpp;orderman/actors/ServiceBridge.cpp;orderman/actors/order_manager/OrderBuilder.cpp;orderman/actors/order_manager/OrderManager.cpp;orderman/actors/order_manager/OrderServicesData.cpp;orderman/events/CancelRejectEvent.cpp;orderman/events/NewExecutionReportEvent.cpp;orderman/limiter/LimitStore.cpp;orderman/limiter/Limiter.cpp;orderman/limiter/ProductLimitNode.cpp;orderman/limiter/ProductLimitTree.cpp;orderman/limiter/SecurityLimitNode.cpp;orderman/limiter/SecurityLimitTree.cpp;orderman/limiter/tests/limit_tests.cpp;orderman/order_factory/OrderFactory.cpp;orderman/order_router/OrderRouter.cpp;orderman/orderman_utils/fix_order_codec.cpp;orderman/orders/IcebergOrder.cpp;orderman/orders/NativeOrder.cpp;orderman/orders/Order.cpp;orderman/orders/TimeBoxOrder.cpp;orderman/orders/TriggerOrder.cpp;orderman/orders/book_algos/BookAlgo.cpp;orderman/orders/book_algos/JoinOrder.cpp;orderman/orders/book_algos/LeanOrder.cpp;orderman/orders/book_algos/TickOrder.cpp;orderman/orders/book_algos/TopOrder.cpp;orderman/orders/spreader_orders/SpreaderOrder.cpp;orderman/orders/spreader_orders/spreader/LegPropertyData.cpp;orderman/orders/spreader_orders/spreader/QuoteLegPriceQuantityState.cpp;orderman/orders/spreader_orders/spreader/SingleFillHedger.cpp;orderman/orders/spreader_orders/spreader/SingleLegQuoter.cpp;orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp;orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.cpp;orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp;orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp;orderman/orders/spreader_orders/spreader/hedger/UnhedgedDelta.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/QuoteDriverSet.cpp;orderman/orders/spreader_orders/spreader/quoter/QuoteDriverSetHistory.cpp;orderman/orders/spreader_orders/spreader/quoter/QuoteLegDriver.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/orders/spreader_orders/tests/spreader_tests.cpp;orderman/server/OrderServiceServer.cpp;orderman/tests/fat_wrapper_tests.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;position/IMarginObserver.cpp;position/IPositionObserver.cpp;position/MarginServiceCore.cpp;position/PositionServiceCore.cpp;position/tests/PositionTests.cpp;support/ErrorReportService.cpp;support/ShellLatencyServer.cpp;tracing/bts_trace_c.c;user/AdminServiceServer.cpp;user/UserServiceServer.cpp;user/tests/admin_service_tests.cpp) \ No newline at end of file diff --git a/src/server/sparkd/orderman/actors/MDSource.h b/src/server/sparkd/orderman/actors/MDSource.h index 4bec8e7b3..a4d293d7d 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,11 +58,11 @@ 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) { - book._security_key = SecurityKey(handle->key()); - corid = cid::make_md_cid(handle->sequence()); + md::HandleReadResult::SUCCESS) { + book._security_key = SecurityKey(handle.key()); + corid = cid::make_md_cid(handle.sequence()); tracepoint (bts_trace,trace_order,(char*) "MDSource", 0, corid,0); publish(_book_update, book, corid); } @@ -73,13 +71,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/order_factory/OrderFactory.cpp b/src/server/sparkd/orderman/order_factory/OrderFactory.cpp index 61a7af6c8..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 @@ -135,7 +136,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::TriggerOrder()); + 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..c5d1d2721 --- /dev/null +++ b/src/server/sparkd/orderman/orders/TriggerOrder.cpp @@ -0,0 +1,360 @@ +#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 "lib/domain_model/Security.h" +#include "lib/os/os.h" +#include +#include + +namespace bts{ +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; + ChildOrder child_order; + Book book; + // this tells that when the order is placed + // 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; + bool is_succ_inited; + PImpl() + : + services(nullptr), + order_def(), + state(), + child_state(), + child_order(), + book(), + market_observed_once(false), + is_cxled(false), + is_recovered(false), + is_succ_inited(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){ + LOG(OrderMan, Info, "TriggerOrder::on_init_new key:{} state:{}", + key(),_state); + switch (_state){ + case State::START: + me->is_succ_inited=_on_init_new(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& rec, + const PreActivationOrderServices& pre_os){ + LOG(OrderMan, Info, "TriggerOrder::on_init_recovered key:{} state:{}", + key(),_state); + 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, + OrderServices& services, + TickToTradeCorID){ + LOG(OrderMan, Info, "TriggerOrder::on_activate key:{} state:{} price:{} qty:{}", + key(),_state, price, qty); + switch (_state){ + case State::START: + me->services=&services; + 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->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);}); + 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: + case State::END:{ + std::ostringstream oss; + oss << "TriggerOrder::on_activate key:" << key() << "state:" << _state; + bts_assert_msg(false,oss.str()); + break; + } + } +} +// order price, qty change +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()); + me->state.set_quantity(qty.value()); + // cant report because does not have order_services yet + 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: + me->state.set_last_msg("Trigger order can not be modified after the trigger has been hit"); + _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){ + LOG(OrderMan, Info, "TriggerOrder::on_cancel key:{} state:{}", + key(),_state); + me->is_cxled=true; + 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: + 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(); + _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; + } + } +} +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())); + 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()){ + _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; + _report_state(); +} +void TriggerOrder::_analyze_trigger(){ + 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); + } + } +} +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: + 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; + } +} +void TriggerOrder::_compute_state(){ + 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){ + 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()>=obs_md->price(); + } + } +} +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]; + 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(); +} +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 new file mode 100644 index 000000000..b32a6e56e --- /dev/null +++ b/src/server/sparkd/orderman/orders/TriggerOrder.h @@ -0,0 +1,72 @@ +#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 book and child order udpates + void _on_book_update(const BookUpdateEvent&); + void _on_child_order_update(OrderStateUpdateEvent const&); +private: + // called from init_new + 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(); + 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(); + // 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; + bool _activated() const; + bool _gr_than_eq(double p1, double p2) 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); 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 (;;) 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