Merge branch 'master' of bitbucket.org:bluetradesys/spark

This commit is contained in:
Pedro Pinto committed 2018-07-19 15:48:08 +00:00
commit bebbf2a0f1
18 files changed
+797 -44

No files matched your search

@@ -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;
}
@@ -18,6 +18,7 @@ namespace mbts.spark {
public static IOrderTypeVM lean(OrdersModel model, IObservable<SecurityImmutable> security_source) => new LeanOrderVM(model, security_source);
public static IOrderTypeVM join(OrdersModel model, IObservable<SecurityImmutable> security_source) => new JoinOrderVM(model, security_source);
public static IOrderTypeVM top(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TopOrderVM(model, security_source);
public static IOrderTypeVM trigger(OrdersModel model, IObservable<SecurityImmutable> security_source) => new TriggerOrderVM(model, security_source);
public static IOrderTypeVM iceberg(OrdersModel model, IObservable<SecurityImmutable> security_source) => new IcebergOrderVM(model, security_source);
public static IOrderTypeVM spreader(OrdersModel model, IObservable<SecurityImmutable> 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();
@@ -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<CustomOneofCase> 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<CustomOneofCase>(selected_child_order_type, true);
this.child_order_types = new InlineUserProperty<IReadOnlyCollection<CustomOneofCase>>(child_order_types, true);
trigger_price_type = new InlineUserProperty<TriggerPriceType>(TriggerPriceType.Bid, false);
order_price = new InlineUserProperty<double>(double.NaN, true);
}
public readonly InlineUserProperty<CustomOneofCase> selected_child_order_type;
public readonly InlineUserProperty<IReadOnlyCollection<CustomOneofCase>> child_order_types;
public readonly InlineUserProperty<TriggerPriceType> trigger_price_type;
public readonly InlineUserProperty<double> order_price;
}
class TriggerOrderVM : OrderTypeVMBase<TriggerOrderDefinition>, IHierarchicalOrderTypeVM, IDisposable
{
readonly IObservable<SecurityImmutable> _security_source;
SecurityImmutable? _security;
ObservableCollection<CustomOneofCase> _order_types = new ObservableCollection<CustomOneofCase>();
ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase> _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<SecurityImmutable> 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<SecurityImmutable> security_source,
IObservable<InlineTriggerOrderProperties> 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<TriggerPriceType> trigger_price_types => EnumHelper.get_values_except<TriggerPriceType>(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<IOrderTypeVM> child_order_types
{
get
{
if (_child_order_choices == null)
_child_order_choices = new ObservableAutoWrapper<IOrderTypeVM, CustomOneofCase>(_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<IDisposable>().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));
}
}
}
}
@@ -335,7 +335,45 @@
/>
</Grid>
</DataTemplate>
</usp:OrderModificationTemplateSelector.TopOrderTemplate>
</usp:OrderModificationTemplateSelector.TopOrderTemplate>
<usp:OrderModificationTemplateSelector.TriggerOrderTemplate>
<DataTemplate>
<Grid>
<Grid.RowDefinitions>
<RowDefinition/>
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition Height="Auto"/>
<RowDefinition Height="4" />
<RowDefinition/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="Auto"/>
<ColumnDefinition Width="12"/>
<ColumnDefinition/>
</Grid.ColumnDefinitions>
<TextBlock Grid.Row="1" VerticalAlignment="Center">Trigger Price Type</TextBlock>
<ComboBox
Grid.Row="1" Grid.Column="2"
ItemsSource="{Binding trigger_price_types}"
ItemTemplate="{StaticResource EnumDescriptionTemplate}"
SelectedItem="{Binding trigger_price_type}"
/>
<TextBlock Grid.Row="3" VerticalAlignment="Center">Order Price</TextBlock>
<usp:PriceEntryControl Grid.Row="3" Grid.Column="2" Value="{Binding order_price}" ContractSpec="{Binding spec}" />
<TextBlock Grid.Row="5">Child</TextBlock>
<uag:OrderDetailsPopupControl
Grid.Row="5" Grid.Column="2"
IsOpen="{Binding child_order.editable_properties_open, FallbackValue=False}"
ItemsSource="{Binding child_order_types}"
SelectedItem="{Binding child_order}"
HasEditableProperties="{Binding child_order.has_editable_properties, FallbackValue=False}"
/>
</Grid>
</DataTemplate>
</usp:OrderModificationTemplateSelector.TriggerOrderTemplate>
<usp:OrderModificationTemplateSelector.IcebergOrderTemplate>
<DataTemplate>
<Grid>
@@ -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() };
+47
View File
@@ -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;
}
}
+29 -10
View File
@@ -298,15 +298,16 @@ private:
class SyntheticConsumerInst {
typedef tbb::queuing_mutex Mutex;
typedef function<map<security_key,MDConsumerHandle>(const set<security_key>&)> IGetHandle;
typedef shared_ptr<SyntheticStrategy> ItemType;
typedef shared_ptr<SyntheticStrategy> StrategyPtr;
struct IncompleteStrategy {
shared_ptr<api::Security> security;
spark::ExecutionStrategy strategy;
};
// LOCK only public methods
Mutex _workmutex;
shared_ptr<api::ISyntheticSecurityService> _ss;
map<security_key, ItemType> _data;
map<security_key, StrategyPtr> _data;
vector<shared_ptr<Security>> _pending;
set<security_key> _seen;
IGetHandle _get_handle;
@@ -341,9 +342,9 @@ class SyntheticConsumerInst {
return _ss->securities().size();
}
const vector<ItemType> get_old_synthetics() {
const vector<StrategyPtr> get_old_synthetics() {
Mutex::scoped_lock lock(_workmutex);
vector<ItemType> result;
vector<StrategyPtr> 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<ItemType> 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<StrategyPtr> 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<ItemType> result;
vector<StrategyPtr> 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<security_key, ItemType> get_synthetic_handles(
static map<security_key, StrategyPtr> get_synthetic_handles(
vector<IncompleteStrategy> synthetics,
const map<security_key, ItemType>& existing,
const map<security_key, StrategyPtr>& existing,
const std::function<map<security_key,MDConsumerHandle>(const set<security_key>&)>& 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<security_key, ItemType> result;
map<security_key, StrategyPtr> 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;
+1 -1
View File
@@ -34,7 +34,7 @@ class BTS_EXPORT MDConsumerHandle
{
public:
MDConsumerHandle();
MDConsumerHandle(const std::shared_ptr<SyntheticStrategy>&);
explicit MDConsumerHandle(const std::shared_ptr<SyntheticStrategy>&);
~MDConsumerHandle();
MDConsumerHandle(const MDConsumerHandle& other);
+1 -1
View File
@@ -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/sLine truncated
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/QuoterWaitingForFirstAckCancLine truncated
+13 -16
View File
@@ -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<api::ISyntheticSecurityService>& 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<BookSide>(),
if (handle.get_depth(h.last, std::tuple_size<BookSide>(),
&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<HandleRecord> _handles;
md::MDRecoverableConsumer _md_consumer;
md::MDConsumer _md_consumer;
mercury::Stream<BookUpdateEvent> _book_update;
std::vector<std::shared_ptr<md::MDConsumerHandle>> _keep_alive;
};
}
}
@@ -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<api::ISyntheticSecurityService>& ss) : md_consumer(ss) {}
PImpl(md::MDConsumer& md) : md_consumer(md) {}
TimeStamp last_scan;
mercury::Stream<NewSecuritiesEvent> new_securities_stream;
std::vector<const api::Security *> to_publish;
md::MDRecoverableConsumer md_consumer;
md::MDConsumer md_consumer;
std::vector<std::unique_ptr<api::Security>> securities_keep_alive;
};
SecuritySrc::SecuritySrc(std::shared_ptr<api::ISyntheticSecurityService>& ss) : me(new PImpl(ss)) {}
SecuritySrc::SecuritySrc(md::MDConsumer& md) : me(new PImpl(md)) {}
SecuritySrc::~SecuritySrc() {}
void SecuritySrc::init() {
@@ -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<api::ISyntheticSecurityService>& ss);
SecuritySrc(md::MDConsumer&);
~SecuritySrc();
void init() override;
@@ -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 <limits>
#include <mutex>
@@ -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;
@@ -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 <algorithm>
#include <sstream>
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;
}
}}
@@ -0,0 +1,72 @@
#pragma once
#include <memory>
#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<PImpl> me;
};
}}
@@ -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);
@@ -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<api::ISyntheticSecurityService>& ss)
: fast_broker(std::make_shared<mercury::AsyncEventBroker>()),
slow_broker(std::make_shared<mercury::AsyncEventBroker>()),
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<api::admin::AdminService>()) {}
admin_service(ctx.locate<api::admin::AdminService>()),
md_consumer(ss) {}
std::shared_ptr<mercury::AsyncEventBroker> fast_broker;
std::shared_ptr<mercury::AsyncEventBroker> 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<api::ISyntheticSecurityService> &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<MDSource>(ss);
me->fast_exe.spawn<MDSource>(me->md_consumer);
me->fast_exe.spawn<OrderManager>();
auto &all_connections = config::get<config::JetFIX>().connection();
@@ -85,7 +89,7 @@ OrderServiceServer::OrderServiceServer(
me->slow_exe.spawn<AsyncFactory>();
me->slow_exe.spawn<OrderStore>();
me->slow_exe.spawn<FillStore>();
me->slow_exe.spawn<SecuritySrc>(ss);
me->slow_exe.spawn<SecuritySrc>(me->md_consumer);
me->slow_thread = std::thread([this]() {
os::set_thread_name("slow_exe");
for (;;)
+1
View File
@@ -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