From 15feef9d239d35d88aa5f648aafb6b2f52785f10 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Mon, 20 Aug 2018 10:02:29 -0400 Subject: [PATCH 1/5] SPARK-1509 queueing in shell --- .../spark/Daemons/ShellLatencyDaemon.cs | 2 +- .../Modules/Trading/OrderBook/OrderBookVM.cs | 6 +- src/client/spark/Orders/FillTupleSource.cs | 8 +- .../spark/Orders/OrderActivitySummarizer.cs | 12 +- .../spark/Orders/OrderRecordTupleSource.cs | 4 +- src/client/spark/Orders/OrdersModel.cs | 38 ++- .../core/GlobalExtensions/GlobalExtensions.cs | 4 - .../spark/core/Utility/ObservableDemuxer.cs | 4 +- .../core/Utility/TableUpdateTransform.cs | 26 +- .../spark/view/Spark/Core/SparkUtils.cs | 17 -- src/client/spark/view/Utility/RXCollection.cs | 29 --- .../api/Channels/QuickBusClientChannel.cs | 34 +-- src/client/spark_api/api/Update.cs | 229 ++++++++++++++--- .../TestRunner/InProcessTestRunner.cs | 4 +- .../spark_core/TestRunner/TestAssert.cs | 16 +- .../TestRunner/TestResultReceiver.cs | 1 + .../spark_core/utils/GlobalExtensions.cs | 6 + src/client/spark_test/api/ApiTests.cs | 16 +- src/client/spark_test/api/ApiUpdateTests.cs | 231 ++++++++++++++++++ src/client/spark_test/api/SomeTests.cs | 11 +- src/client/spark_test/spark_test.csproj | 1 + src/lib/CMakeDeps.cmake | 2 +- 22 files changed, 540 insertions(+), 161 deletions(-) create mode 100644 src/client/spark_test/api/ApiUpdateTests.cs diff --git a/src/client/spark/Daemons/ShellLatencyDaemon.cs b/src/client/spark/Daemons/ShellLatencyDaemon.cs index 4e7c09760..827e80d49 100644 --- a/src/client/spark/Daemons/ShellLatencyDaemon.cs +++ b/src/client/spark/Daemons/ShellLatencyDaemon.cs @@ -29,7 +29,7 @@ namespace bts.perf { } void on_tick(Update update) { - if (update.added.Count > 0) { + if (update.added.Any()) { var tick = update.added.Last(); _service.report_async(new Report() { HostName = _hostname, diff --git a/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs b/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs index 749b31368..c20eeea34 100644 --- a/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs +++ b/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs @@ -69,13 +69,13 @@ namespace mbts.spark { _dispose = Disposable.Create( bus.subscribe(SparkTags.SecuritiesTag).OnDispatcher().Subscribe(on_securities), - model.on_orders.OnDispatcher().Subscribe(on_orders), + model.on_orders.OnDispatcher().AddRemoveOnly().Subscribe(on_orders), grid_settings_manager, columns); - void on_orders(TableUpdate table) { + void on_orders(LegacyTableUpdate table) { // clear everything (most likely the server restarted) - if (table.removed.Count == _order_rows.Count && table.added.Count == 0) { + if (table.removed.Count() == _order_rows.Count && !table.added.Any()) { _selected_rows.Clear(); _order_rows.DisposeAll(); _order_rows.Clear(); diff --git a/src/client/spark/Orders/FillTupleSource.cs b/src/client/spark/Orders/FillTupleSource.cs index 3e2d90dab..d5c09c356 100644 --- a/src/client/spark/Orders/FillTupleSource.cs +++ b/src/client/spark/Orders/FillTupleSource.cs @@ -53,7 +53,7 @@ namespace mbts.spark { _dispose = Disposable.Create( securities.OnDispatcher().Subscribe(_update_securities), orders.OnDispatcher().Subscribe(_update_orders), - fills.OnDispatcher().Subscribe(_update_fills)); + fills.OnDispatcher().AddRemoveOnly().Subscribe(_update_fills)); public IDisposable Subscribe(IObserver> observer) { using (_read()) { @@ -64,9 +64,11 @@ namespace mbts.spark { public void Dispose() => Disposable.dispose(ref _dispose); - void _update_fills(TableUpdate fills) { + void _update_fills(LegacyTableUpdate fills) { using (_write()) { - Dictionary removed = new Dictionary(), added = new Dictionary(); + var removed = new Dictionary(); + var added = new Dictionary(); + foreach (FillImmutable fill in fills.removed) { FillTuple old_ft = new FillTuple(fill, _get_order(fill.OrderKey), _get_security_md(fill.SecurityKey)); removed.Add(old_ft.key, old_ft); diff --git a/src/client/spark/Orders/OrderActivitySummarizer.cs b/src/client/spark/Orders/OrderActivitySummarizer.cs index 7e3c7e7ef..ed3327560 100644 --- a/src/client/spark/Orders/OrderActivitySummarizer.cs +++ b/src/client/spark/Orders/OrderActivitySummarizer.cs @@ -114,14 +114,7 @@ namespace bts.spark { void orders_updated(TableUpdate update) { - // Go though added and changed orders - var added = new HashSet(update.added, _id_comparer); - var changed = new HashSet(update.added, _id_comparer); - var removed = update.removed.ToDictionary(o => o.Key); - added.ExceptWith(update.removed); - changed.ExceptWith(added); - - foreach (var order in added) { + foreach (var order in update.added) { if (!string.IsNullOrEmpty(order.State.LastMsg) && order.State.Created.ToDateTime().Date == DateTime.Today) { (var security, var spec) = get_security(order.Def.SecurityKey); if (security.HasValue) { @@ -130,8 +123,7 @@ namespace bts.spark { } } - foreach (var neworder in changed) { - var oldorder = removed[neworder.Key]; + foreach (var (neworder, oldorder) in update.changes) { (var security, var spec) = get_security(neworder.Def.SecurityKey); // // description diff --git a/src/client/spark/Orders/OrderRecordTupleSource.cs b/src/client/spark/Orders/OrderRecordTupleSource.cs index 114859b1c..2b57ebfa9 100644 --- a/src/client/spark/Orders/OrderRecordTupleSource.cs +++ b/src/client/spark/Orders/OrderRecordTupleSource.cs @@ -45,7 +45,7 @@ namespace mbts.spark { OrderRecordTupleSource(IObservable> securities, IObservable> orders) => _dispose = Disposable.Create( securities.OnDispatcher().Subscribe(_update_securities), - orders.OnDispatcher().Subscribe(_update_orders)); + orders.OnDispatcher().AddRemoveOnly().Subscribe(_update_orders)); public IDisposable Subscribe(IObserver> observer) { using (_rw_gate.read()) { @@ -56,7 +56,7 @@ namespace mbts.spark { public void Dispose() => Disposable.dispose(ref _dispose); - void _update_orders(TableUpdate orders) { + void _update_orders(LegacyTableUpdate orders) { using (_rw_gate.write()) { Dictionary removed = new Dictionary(), added = new Dictionary(); foreach (OrderRecordImmutable order in orders.removed) { diff --git a/src/client/spark/Orders/OrdersModel.cs b/src/client/spark/Orders/OrdersModel.cs index 4a5b2a51a..d54a96675 100644 --- a/src/client/spark/Orders/OrdersModel.cs +++ b/src/client/spark/Orders/OrdersModel.cs @@ -7,9 +7,11 @@ using mbts.spark.utilities; using mbts.utils; using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Collections.Specialized; using System.ComponentModel.Composition; using System.Linq; +using System.Reactive.Concurrency; using System.Reactive.Linq; using System.Threading.Tasks; @@ -32,17 +34,21 @@ namespace mbts.spark { _service = service; _spreader = spreader; _error = error; - on_orders = _service.subscribei_orders().Table().Cache(); - IReadOnlyDictionary empty_orders = new Dictionary(); + var scheduler = ThreadPoolScheduler.Instance; + var interval = TimeSpan.FromMilliseconds(100); + on_orders = _service.subscribei_orders().Naggle(interval, scheduler).Table().Cache(); working_orders = - on_orders.Scan(empty_orders, (worders, table) => _update_working_orders(worders, table)).Replay(1).RefCount(); + on_orders.Scan( + ImmutableDictionary.Empty, + (workers, table) => _update_working_orders(workers, table)) + .Replay(1).RefCount(); on_order_tuples = OrderRecordTupleSource.create_observable(bus.subscribe(SparkTags.SecuritiesTag), on_orders); - on_fills = _service.subscribei_fills().Table().Cache(); + on_fills = _service.subscribei_fills().Naggle(interval, scheduler).Table().Cache(); _activity = new OrderActivitySummarizer(bus, on_orders); on_fill_tuples = FillTupleSource.create_observable(bus.subscribe(SparkTags.SecuritiesTag), on_orders, on_fills); _security_orders_demuxer = new TableUpdateDemuxer(o => o.Key, o => o.security_key()); _dispose = Disposable.Create( - on_orders.Subscribe(_security_orders_demuxer), + on_orders.AddRemoveOnly().Subscribe(_security_orders_demuxer), _bus.subscribe(SparkTags.CreateOrder).Subscribe(a => send_order(a.definition, a.price, a.size).ignore()), _bus.subscribe(SparkTags.RecreateOrder).Subscribe(a => a.ForEach(x => send_order(x.definition, x.price, x.size).ignore())), _bus.subscribe(SparkTags.CancelOrders).Subscribe(x => cancel_orders(x).ignore()), @@ -122,17 +128,27 @@ namespace mbts.spark { public void Dispose() => Disposable.dispose(ref _dispose); - static IReadOnlyDictionary _update_working_orders(IReadOnlyDictionary target, TableUpdate table) { - var clone = new Dictionary((IDictionary)target); + static ImmutableDictionary _update_working_orders(ImmutableDictionary target, TableUpdate table) { + var clone = target.ToBuilder(); foreach (var o in table.removed) { - if (o.is_active()) + if (o.is_active()) { clone.Remove(o.Key); + } + } + foreach (var o in table.changed) { + if (o.is_active()) { + clone[o.Key] = o; + } + else { + clone.Remove(o.Key); + } } foreach (var o in table.added) { - if (o.is_active()) + if (o.is_active()) { clone.Add(o.Key, o); + } } - return clone; + return clone.ToImmutableDictionary(); } } @@ -235,7 +251,7 @@ namespace mbts.spark { } // ** [continue comment at top of method] this call would otherwise be: // rod.last_update = rod.last_update.update(removed_dict.Values.ToList(), added_dict.Values.ToList(), o => o.Key) ** - rod.last_update = rod.last_update.update(removed_roots, added_roots, o => o.Key); + //rod.last_update = rod.last_update.update(removed_roots, added_roots, o => o.Key); return rod; }).Select(r => r.last_update); diff --git a/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs b/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs index 4cd9fed60..e4556752d 100644 --- a/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs +++ b/src/client/spark/core/GlobalExtensions/GlobalExtensions.cs @@ -70,10 +70,6 @@ namespace mbts } #endregion - public static T choose(this Random r, IEnumerable range) { - var index = r.Next(0, range.Count()); - return range.Skip(index).First(); - } // Iterate through a list 1,2,3,4 and return the items in pairwise tuples (1,2), (2,3), (3,4) // This is better than using Zip+Skip because it iterates the collectiononly once diff --git a/src/client/spark/core/Utility/ObservableDemuxer.cs b/src/client/spark/core/Utility/ObservableDemuxer.cs index 59b82e9ce..d51e9dc2a 100644 --- a/src/client/spark/core/Utility/ObservableDemuxer.cs +++ b/src/client/spark/core/Utility/ObservableDemuxer.cs @@ -81,7 +81,7 @@ namespace mbts.utils { protected override IDictionary demux(IDictionary input) => input; } - class TableUpdateDemuxer : IObservableDemuxer, ITableUpdateTransform> + class TableUpdateDemuxer : IObservableDemuxer, ITableUpdateTransform> where TKey : IEquatable where TGroupKey : IEquatable { readonly ConcurrentDictionary _map = new ConcurrentDictionary(); @@ -104,7 +104,7 @@ namespace mbts.utils { public void OnCompleted() { } public void OnError(Exception error) { } - public void OnNext(TableUpdate table) { + public void OnNext(LegacyTableUpdate table) { var changes = new Dictionary(); foreach (T value in table.added) changes.AddOrUpdate(_group_key(value), gk => ChangeSet.from_added(value), (gk, cs) => cs.added.Add(value)); diff --git a/src/client/spark/core/Utility/TableUpdateTransform.cs b/src/client/spark/core/Utility/TableUpdateTransform.cs index bf4fe4e6e..a694fafe3 100644 --- a/src/client/spark/core/Utility/TableUpdateTransform.cs +++ b/src/client/spark/core/Utility/TableUpdateTransform.cs @@ -14,8 +14,8 @@ namespace mbts.utils { interface ITableUpdateTransform where TKey : IEquatable { IReadOnlyDictionary state { get; } - IReadOnlyList added { get; } - IReadOnlyList removed { get; } + IEnumerable added { get; } + IEnumerable removed { get; } } class IncrementalUpdate : IIncrementalUpdate where TKey : IEquatable { @@ -33,20 +33,20 @@ namespace mbts.utils { class TableUpdateTransform : ITableUpdateTransform where TKey : IEquatable { readonly Dictionary _state; - readonly IReadOnlyList _added, _removed; + readonly IEnumerable _added, _removed; internal TableUpdateTransform() : this(new Dictionary(), new List(0), new List(0)) { } - internal TableUpdateTransform(Dictionary init, IReadOnlyList added, IReadOnlyList removed) { + internal TableUpdateTransform(Dictionary init, IEnumerable added, IEnumerable removed) { _state = init; _added = added; _removed = removed; } public IReadOnlyDictionary state => _state; - public IReadOnlyList added => _added; - public IReadOnlyList removed => _removed; + public IEnumerable added => _added; + public IEnumerable removed => _removed; public TableUpdateTransform update(Update update) => this.update(update.removed, update.added, update.key); @@ -54,7 +54,7 @@ namespace mbts.utils { public TableUpdateTransform update(TableUpdate update, Func key) => this.update(update.removed, update.added, key); - public TableUpdateTransform update(IReadOnlyList removed, IReadOnlyList added, Func key) { + public TableUpdateTransform update(IEnumerable removed, IEnumerable added, Func key) { var table = new TableUpdateTransform(new Dictionary(_state), added, removed); foreach (var item in removed) table._state.Remove(key(item)); @@ -86,7 +86,7 @@ namespace mbts.utils { public static IObservable> filter(this IObservable> source, Func predicate) where TKey : IEquatable => source .Select(u => new FilteredTableUpdateTransform(u, predicate)) - .Where(u => u.added.Count > 0 || u.removed.Count > 0); + .Where(u => u.added.Any() || u.removed.Any()); /// /// Makes a 1:1 conversion to an IncrementalUpdate sequence of TResult (TKey remains the same). @@ -143,8 +143,8 @@ namespace mbts.utils { } public IReadOnlyDictionary state { get; } - public IReadOnlyList added { get; } - public IReadOnlyList removed { get; } + public IEnumerable added { get; } + public IEnumerable removed { get; } } class PivotIncrementalUpdate : IIncrementalUpdate where TKey : IEquatable where TResultKey : IEquatable { @@ -208,7 +208,7 @@ namespace mbts.utils { internal PivotTableUpdateTransform(Func selector, Func result_key, Func key) : this(new Dictionary(), new List(0), new List(0), new SetMap(), selector, result_key, key) { } - PivotTableUpdateTransform(Dictionary state, IReadOnlyList added, IReadOnlyList removed, + PivotTableUpdateTransform(Dictionary state, IEnumerable added, IEnumerable removed, SetMap key_map, Func selector, Func result_key, Func key) { // _state = state; @@ -221,8 +221,8 @@ namespace mbts.utils { } public IReadOnlyDictionary state => _state; - public IReadOnlyList added { get; } - public IReadOnlyList removed { get; } + public IEnumerable added { get; } + public IEnumerable removed { get; } public PivotTableUpdateTransform update(ITableUpdateTransform table) { Dictionary removed = new Dictionary(), added = new Dictionary(); diff --git a/src/client/spark/view/Spark/Core/SparkUtils.cs b/src/client/spark/view/Spark/Core/SparkUtils.cs index 20e5f6b6e..0a67b4167 100644 --- a/src/client/spark/view/Spark/Core/SparkUtils.cs +++ b/src/client/spark/view/Spark/Core/SparkUtils.cs @@ -94,23 +94,6 @@ namespace mbts.spark { public static bool try_get(this TableUpdate table, TKey key, out T result) where TKey : IEquatable => table.state.TryGetValue(key, out result); - public static void detect_changed_keys(this TableUpdate table, Func key_selector, out HashSet removed_keys, out HashSet added_keys, out HashSet changed_keys) - where TKey : IEquatable { - removed_keys = new HashSet(table.removed.Select(key_selector)); - added_keys = new HashSet(table.added.Select(key_selector)); - changed_keys = new HashSet(removed_keys.Intersect(added_keys)); - removed_keys.ExceptWith(changed_keys); - added_keys.ExceptWith(changed_keys); - } - - public static void detect_changed_keys(this ITableUpdateTransform table, Func key_selector, out HashSet removed_keys, out HashSet added_keys, out HashSet changed_keys) - where TKey : IEquatable { - removed_keys = new HashSet(table.removed.Select(key_selector)); - added_keys = new HashSet(table.added.Select(key_selector)); - changed_keys = new HashSet(removed_keys.Intersect(added_keys)); - removed_keys.ExceptWith(changed_keys); - added_keys.ExceptWith(changed_keys); - } #endregion public static class UI { diff --git a/src/client/spark/view/Utility/RXCollection.cs b/src/client/spark/view/Utility/RXCollection.cs index 42d2e4f2d..135dbb0e3 100644 --- a/src/client/spark/view/Utility/RXCollection.cs +++ b/src/client/spark/view/Utility/RXCollection.cs @@ -52,17 +52,6 @@ namespace mbts.ui.utility { } }); - public static ITableUpdateCollection CreateTableUpdate(IObservable> source) where TKey : IEquatable => - CreateTableUpdate(source, _ => true); - - public static ITableUpdateCollection CreateTableUpdate(IObservable> source, Func collection_filter) where TKey : IEquatable => - new TableUpdateCollection(source, collection_filter ?? new Func(_ => true)); - - public static ITableUpdateCollection CreateTableUpdate(IObservable> source) where TKey : IEquatable => - CreateTableUpdate(source, _ => true); - - public static ITableUpdateCollection CreateTableUpdate(IObservable> source, Func collection_filter) where TKey : IEquatable => - new TableUpdateTransformCollection(source, collection_filter ?? new Func(_ => true)); public static IRXCollection CreateIncrementalUpdate(IObservable> source) where TKey : IEquatable => new IncrementalUpdateCollection(source); @@ -83,24 +72,6 @@ namespace mbts.ui.utility { public void Dispose() => Disposable.dispose(ref _sub); } - class TableUpdateCollection : ObservableCollection, ITableUpdateCollection where TKey : IEquatable { - readonly Func _collection_filter; - IReadOnlyDictionary _raw_state = new ReadOnlyDictionary(new Dictionary()); - IDisposable _sub; - - internal TableUpdateCollection(IObservable> source, Func collection_filter) { - _collection_filter = collection_filter; - _sub = source.OnDispatcher().Subscribe(u => { - _raw_state = u.state; - foreach (T val in u.removed.Where(_collection_filter)) Remove(val); - foreach (T val in u.added.Where(_collection_filter)) Add(val); - }); - } - - public bool TryGetValue(TKey key, out T result) => _raw_state.TryGetValue(key, out result); - public void Dispose() => Disposable.dispose(ref _sub); - } - class TableUpdateTransformCollection : ObservableCollection, ITableUpdateCollection where TKey : IEquatable { readonly Func _collection_filter; IReadOnlyDictionary _raw_state = new ReadOnlyDictionary(new Dictionary()); diff --git a/src/client/spark_api/api/Channels/QuickBusClientChannel.cs b/src/client/spark_api/api/Channels/QuickBusClientChannel.cs index 52ccac268..6cf3ecb6b 100644 --- a/src/client/spark_api/api/Channels/QuickBusClientChannel.cs +++ b/src/client/spark_api/api/Channels/QuickBusClientChannel.cs @@ -57,30 +57,34 @@ namespace bts.api.core { } public unsafe override IObservable> subscribe(string method_and_qualifier, MessageParser parser, Func converter) { - bool first_update = true; var result = Observable.Create>(observer => { + bool first_update = true; + // Memory optimization. There is only one update per subscription. + RawUpdate the_update = new RawUpdate(); ApiNativeMethods.raw_subscription_callback cb = (event_type, changes, change_count, unused) => { + the_update.Clear(); try { if (event_type == ApiNativeMethods.EventType.TABLE_UPDATED) { - var added_items = new List(change_count); - var added_keys = new List(change_count); - var removed_keys = new List(change_count); foreach (var change in changes) { - if (change.type != ApiNativeMethods.ChangeType.REMOVE) { - // create or change - added_items.Add( converter( parser.ParseFrom(new UnmanagedMemoryStream(change.buffer, change.buffer_len)))); - added_keys.Add(change.key); - } - if (change.type != ApiNativeMethods.ChangeType.CREATE) { - // removed or changed - removed_keys.Add(change.key); + switch (change.type) { + case ApiNativeMethods.ChangeType.REMOVE: + the_update.removed_keys.Add(change.key); + break; + case ApiNativeMethods.ChangeType.REPLACE: + the_update.changed_items.Add(converter(parser.ParseFrom(new UnmanagedMemoryStream(change.buffer, change.buffer_len)))); + the_update.changed_keys.Add(change.key); + break; + case ApiNativeMethods.ChangeType.CREATE: + the_update.added_items.Add(converter(parser.ParseFrom(new UnmanagedMemoryStream(change.buffer, change.buffer_len)))); + the_update.added_keys.Add(change.key); + break; } } - observer.OnNext(new RawUpdate(added_items, added_keys, removed_keys)); + observer.OnNext(the_update); } else if (event_type == ApiNativeMethods.EventType.TABLE_CREATED) { if (!first_update) { - observer.OnNext(RawUpdate.Reset()); + observer.OnNext(the_update.MarkAsReset()); } first_update = false; } @@ -88,7 +92,7 @@ namespace bts.api.core { catch (Exception e) { ApiNativeMethods.api_client_log_error($"Exception in subscription callback for sub: '{method_and_qualifier}' \n--\n '{e}'"); // Sleep to let the log message get asyncronously written to disk - System.Threading.Thread.Sleep(100); + Thread.Sleep(100); Environment.Exit(-1); } }; diff --git a/src/client/spark_api/api/Update.cs b/src/client/spark_api/api/Update.cs index 85056d0e0..075485975 100644 --- a/src/client/spark_api/api/Update.cs +++ b/src/client/spark_api/api/Update.cs @@ -1,84 +1,204 @@ using System; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Collections.Immutable; +using System.Diagnostics; using System.Linq; +using System.Reactive.Concurrency; +using System.Reactive.Disposables; using System.Reactive.Linq; namespace bts.api.core { - public struct RawUpdate { + class RawUpdate { // RawUpdate uses List instead of IReadonlyList to avoid virtual dispatch on a type not likely to be see in a public api surface - public RawUpdate(List added_items, List added_keys, List removed_keys) : this() { + // There is a single stack allocated RawUpdate per subscription + public RawUpdate() { is_reset = false; - this.added_items = added_items; - this.added_keys = added_keys; - this.removed_keys = removed_keys; + added_items = new List(); + added_keys = new List(); + changed_items = new List(); + changed_keys = new List(); + removed_keys = new List(); + } + public RawUpdate MarkAsReset() { + Clear(); + is_reset = true; + return this; } - public static RawUpdate Reset() { - return new RawUpdate() { is_reset = true }; + public void Clear() { + is_reset = false; + added_items.Clear(); + added_keys.Clear(); + changed_items.Clear(); + changed_keys.Clear(); + removed_keys.Clear(); } + public bool is_reset { get; private set; } + public List added_items { get; } + public List added_keys { get; } + public List changed_items { get; } + public List changed_keys { get; } + public List removed_keys { get; } - public bool is_reset; - public List added_items { get; private set; } - public List added_keys { get; private set; } - public List removed_keys { get; private set; } +#if DEBUG + public override string ToString() { + var added = string.Join(", ", added_items); + var changed = string.Join(", ", changed_items); + var removed = string.Join(", ", removed_keys); + return $"added [{added}] changed [{changed}] removed [{removed}]"; + } +#endif } public class Update where TKey : IEquatable { private Func _key; - public Update(IReadOnlyCollection all, IReadOnlyList added, IReadOnlyList removed, Func key_extractor) { + internal Update( + IReadOnlyCollection all, + IEnumerable added, + IEnumerable<(T New,T Old)> changes, + IEnumerable removed, + Func key_extractor) { this.added = added; this.removed = removed; + this.changes = changes; this.all = all; _key = key_extractor; } - public IReadOnlyCollection all { get; private set; } - public IReadOnlyList added { get; private set; } - public IReadOnlyList removed { get; private set; } + public static Update empty(Func key_extractor) => + new Update(new T[0], new T[0], new (T,T)[0], new T[0], key_extractor); + + public Update merge(Update next) { + var comp = new RowEqualityComparer(_key); + var added = this.added as HashSet ?? new HashSet(this.added, comp); + var changes = this.changed as HashSet<(T New,T Old)> ?? new HashSet<(T,T)>(this.changes, comp); + var removed = this.removed as HashSet ?? new HashSet(this.removed, comp); + + // Add + added.UnionWith(next.added); + + // Change + foreach (var c in next.changes) { + if (added.Contains(c.Old)) { + added.Remove(c.Old); + added.Add(c.New); + } + else { + // Remove does not error if it was not present + changes.Remove(c); + changes.Add(c); + } + } + + // Remove + foreach (var r in next.removed) { + if (!added.Remove(r)) { + removed.Add(r); + } + changes.Remove((r,r)); + } + + return new Update( + next.all, + added, changes, removed, + _key + ); + } + + public IReadOnlyCollection all { get; } + public IEnumerable added { get; } + public IEnumerable<(T New,T Old)> changes { get; } + public IEnumerable changed => changes.Select(c => c.New); + public IEnumerable removed { get; } public TKey key(T t) { return _key(t); } } + struct RowEqualityComparer : IEqualityComparer, IEqualityComparer<(T,T)> + where TKey : IEquatable { + readonly Func _key; + + public RowEqualityComparer(Func key) { + _key = key; + } + + public bool Equals(T x, T y) { + return _key(x).Equals(_key(y)); + } + + public bool Equals((T, T) x, (T, T) y) { + return Equals(x.Item1, y.Item1); + } + + public int GetHashCode(T obj) { + return _key(obj).GetHashCode(); + } + + public int GetHashCode((T, T) obj) { + return GetHashCode(obj.Item1); + } + } + public class TableUpdate where TKey : IEquatable { - ImmutableDictionary _state; + readonly ImmutableDictionary _state; - internal TableUpdate(ImmutableDictionary init, IReadOnlyList added, IReadOnlyList removed) { + internal TableUpdate( + ImmutableDictionary init, + IEnumerable added, + IEnumerable<(T,T)> changed, + IEnumerable removed) { _state = init; this.added = added; + this.changes = changed; this.removed = removed; } public IReadOnlyDictionary state { get { return _state; } } - public IReadOnlyList added { get; } - public IReadOnlyList removed { get; } + public IEnumerable added { get; } + public IEnumerable<(T New,T Old)> changes { get; } + public IEnumerable changed => changes.Select(c => c.New); - internal TableUpdate update(Update update) => - this.update(update.removed, update.added, update.key); + public IEnumerable removed { get; } - internal TableUpdate update(IReadOnlyList removed, IReadOnlyList added, Func key) { - var builder = _state.ToBuilder(); - builder.RemoveRange(removed.Select(i => key(i))); - builder.AddRange(added.Select(i => new KeyValuePair(key(i), i))); - return new TableUpdate(builder.ToImmutableDictionary(), added, removed); + internal static TableUpdate update(TableUpdate table, Update update) { + var builder = table._state.ToBuilder(); + builder.RemoveRange(update.removed.Select(i => update.key(i))); + builder.AddRange(update.added.Select(i => new KeyValuePair(update.key(i), i))); + foreach (var i in update.changed) { + builder[update.key(i)] = i; + } + return new TableUpdate(builder.ToImmutableDictionary(), update.added, update.changes, update.removed); } internal TableUpdate as_snapshot() { - return new TableUpdate(_state, _state.Values.ToList(), new T[0]); + return new TableUpdate(_state, _state.Values.ToList(), new (T,T)[0], new T[0]); } } + internal class LegacyTableUpdate where TKey : IEquatable { + public LegacyTableUpdate( + TableUpdate update) { + this.state = update.state; + this.added = update.added.Concat(update.changes.Select(t => t.New)); + this.removed = update.removed.Concat(update.changes.Select(t => t.Old)); + } + public IReadOnlyDictionary state { get; } + public IEnumerable added { get; } + public IEnumerable removed { get; } + } + public static class ObservableUpdateExtensions { - public static IObservable> reconstitute(this IObservable> source, Func key_extractor) where TKey : IEquatable { + internal static IObservable> reconstitute(this IObservable> source, Func key_extractor) where TKey : IEquatable { var state = new Dictionary(); return source.Select(raw => { if (raw.is_reset) { var removed = state.Values.ToList(); state.Clear(); - return new Update(new T[0], new T[0], removed, key_extractor); + return new Update(new T[0], new T[0], new (T,T)[0], removed, key_extractor); } else { var removed = new List(raw.removed_keys.Count); @@ -92,15 +212,56 @@ namespace bts.api.core { for (int x = 0; x < raw.added_items.Count; ++x) { state[raw.added_keys[x]] = raw.added_items[x]; } - return new Update(state.Values, raw.added_items, removed, key_extractor); + List<(T, T)> changes = new List<(T, T)>(raw.changed_items.Count); + for (int x = 0; x < raw.changed_items.Count; ++x) { + var old = state[raw.changed_keys[x]]; + state[raw.changed_keys[x]] = raw.changed_items[x]; + changes.Add((raw.changed_items[x], old)); + } + return new Update(state.Values.ToList(), raw.added_items.ToList(), changes, removed, key_extractor); } }); } public static IObservable> Table(this IObservable> source) where TKey : IEquatable => source.Scan( - new TableUpdate(ImmutableDictionary.Empty, new List(), new List()), - (table, update) => table.update(update)); + new TableUpdate(ImmutableDictionary.Empty, new T[0], new (T,T)[0], new T[0]), + (table, update) => TableUpdate.update(table,update)); + + // Fold updates and emit at max 1/interval + public static IObservable> Naggle(this IObservable> source, TimeSpan interval, IScheduler scheduler) where TKey : IEquatable { + // fold updates together and emit on TimeSpan (max) interval. Emit on threadpool + return Observable.Create>(observer => { + object guard = new object(); + Update cache = null; + bool finished = false; + + var d1 = source.Subscribe(update => { + // subscribe to the source, merge updates (Quickbus thread) + lock (guard) { + if (cache == null) cache = update; + else cache = cache.merge(update); + } + }, + () => { finished = true; }); + // publish on interval + var d2 = Observable.Interval(interval, scheduler).Subscribe(_ => { + Update update; + lock (guard) { + update = cache; + cache = null; + } + if (update != null) { + observer.OnNext(update); + } + if (finished) { + observer.OnCompleted(); + } + }); + + return new CompositeDisposable(d1, d2); + }); + } public static IObservable> Cache(this IObservable> source) where TKey : IEquatable { var inner = source.Replay(1).RefCount(); @@ -118,5 +279,9 @@ namespace bts.api.core { }); } + internal static IObservable> AddRemoveOnly(this IObservable> source) where TKey : IEquatable { + return source.Select(t => new LegacyTableUpdate(t)); + } + } } \ No newline at end of file diff --git a/src/client/spark_core/TestRunner/InProcessTestRunner.cs b/src/client/spark_core/TestRunner/InProcessTestRunner.cs index 7e3a22f45..4bab68419 100644 --- a/src/client/spark_core/TestRunner/InProcessTestRunner.cs +++ b/src/client/spark_core/TestRunner/InProcessTestRunner.cs @@ -37,11 +37,11 @@ namespace bts.test { result.Status = TestResult.Types.Step.Pass; } catch (AssertFailture af) { - result.Message = $"Assertion Failure: {af.Message}\nLocation:{af._filename}:{af._line}"; + result.Message = $"Assertion Failure:\n{af.Message}\nLocation:{af._filename}:{af._line}"; } catch (Exception ue) { if (ue.InnerException is AssertFailture af) { - result.Message = $"Assertion Failure: {af.Message}\nLocation:{af._filename}:{af._line}"; + result.Message = $"Assertion Failure:\n{af.Message}\nLocation:{af._filename}:{af._line}"; } else { result.Message = $"Unexpected error: {ue.Message}\n\n{ue.StackTrace}"; diff --git a/src/client/spark_core/TestRunner/TestAssert.cs b/src/client/spark_core/TestRunner/TestAssert.cs index 6c0267d1b..9351f1d79 100644 --- a/src/client/spark_core/TestRunner/TestAssert.cs +++ b/src/client/spark_core/TestRunner/TestAssert.cs @@ -18,28 +18,32 @@ namespace bts.test { } public static void IsTrue(bool test, string msg="", [CallerFilePath] string file="", [CallerLineNumber] int line=0) { if (!test) { - throw new AssertFailture($"Expected 'true' got 'false'. {msg}", file, line); + throw new AssertFailture($"Expected: 'true' got 'false'. {msg}", file, line); } } + public static void That(bool test, string msg = "", [CallerFilePath] string file = "", [CallerLineNumber] int line = 0) { + Assert.IsTrue(test, msg, file, line); + } public static void IsFalse(bool test, string msg="", [CallerFilePath] string file="", [CallerLineNumber] int line=0) { if (test) { - throw new AssertFailture($"Expected 'false' got 'true'. {msg}", file, line); + throw new AssertFailture($"Expected: 'false' got 'true'. {msg}", file, line); } } public static void AreEqual(T a, T b, string msg="", [CallerFilePath] string file="", [CallerLineNumber] int line=0) { if (!a.Equals(b)) { throw new AssertFailture( - $"Expected '{a}' == '{b}'. {msg}", file, line); + $"Expected: '{a}' == '{b}'. {msg}", file, line); } } - public static void AreEqual(IEnumerable a, IEnumerable b, string msg="", [CallerFilePath] string file="", [CallerLineNumber] int line=0) { + public static void SequenceEqual(IEnumerable a, IEnumerable b, string msg="", [CallerFilePath] string file="", [CallerLineNumber] int line=0) { if (!a.SequenceEqual(b)) { var aa = string.Join(", ", a); var bb = string.Join(", ", b); throw new AssertFailture( - $"Expected [{aa}] == [{bb}]. {msg}", file, line); + $"Expected: [{aa}]\nGot: [{bb}]. {msg}", file, line); } } + public static void IsNotNull(T a, string msg="", [CallerFilePath] string file="", [CallerLineNumber] int line=0) where T : class { @@ -53,7 +57,7 @@ namespace bts.test { if (!items.Contains(item)) { var aa = string.Join(", ", items); throw new AssertFailture( - $"Expected {item} in [{aa}]. {msg}", file, line); + $"Expected: {item} in [{aa}]. {msg}", file, line); } } } diff --git a/src/client/spark_core/TestRunner/TestResultReceiver.cs b/src/client/spark_core/TestRunner/TestResultReceiver.cs index 1afd28780..72a052c84 100644 --- a/src/client/spark_core/TestRunner/TestResultReceiver.cs +++ b/src/client/spark_core/TestRunner/TestResultReceiver.cs @@ -61,6 +61,7 @@ namespace bts.test { if (!string.IsNullOrEmpty(type)) { ConsoleEx.Write($" - {type}", ConsoleColor.DarkRed); } + Console.WriteLine(); if (!string.IsNullOrEmpty(result.Message)) { ConsoleEx.Write("==>", ConsoleColor.White, ConsoleColor.DarkRed); Console.Write(" "); diff --git a/src/client/spark_core/utils/GlobalExtensions.cs b/src/client/spark_core/utils/GlobalExtensions.cs index 1bd8a164e..3c05994a1 100644 --- a/src/client/spark_core/utils/GlobalExtensions.cs +++ b/src/client/spark_core/utils/GlobalExtensions.cs @@ -1,4 +1,6 @@ using System; +using System.Collections.Generic; +using System.Linq; using System.Runtime.InteropServices; using System.Text; @@ -17,6 +19,10 @@ namespace mbts { } return sb.ToString(); } + public static T choose(this Random r, IEnumerable range) { + var index = r.Next(0, range.Count()); + return range.Skip(index).First(); + } [DllImport("libspark")] private static extern void ll_to_parts(UInt64 ll_time, out int year, out int month, out int day, out int hour, out int minute, out int second, out int ms); diff --git a/src/client/spark_test/api/ApiTests.cs b/src/client/spark_test/api/ApiTests.cs index d0f1d3e12..d1682bdb7 100644 --- a/src/client/spark_test/api/ApiTests.cs +++ b/src/client/spark_test/api/ApiTests.cs @@ -77,16 +77,16 @@ namespace mbts.api.Test { var response = h.say_hello(new HelloRequest() { Name = "UnitTest 1" }); Assert.AreEqual("Hello UnitTest 1", response.Message); Assert.IsNotNull(last_update); - Assert.IsTrue(last_update.added.Count == 1); - Assert.IsTrue(last_update.removed.Count == 0); + Assert.IsTrue(last_update.added.Count() == 1); + Assert.IsTrue(last_update.removed.Count() == 0); Assert.IsTrue(last_update.state.Count == 1); Assert.IsTrue(last_update.state.Single().Value.Message == "Hello UnitTest 1"); last_update = null; response = h.yell_hello(new HelloRequest() { Name = "UnitTest 2" }); Assert.AreEqual("HELLO UNITTEST 2", response.Message); Assert.IsNotNull(last_update); - Assert.IsTrue(last_update.added.Count == 1); - Assert.IsTrue(last_update.removed.Count == 1); + Assert.IsTrue(last_update.added.Count() == 1); + Assert.IsTrue(last_update.removed.Count() == 1); Assert.IsTrue(last_update.state.Count == 1); Assert.IsTrue(last_update.state.Single().Value.Message == "HELLO UNITTEST 2"); last_update = null; @@ -97,8 +97,8 @@ namespace mbts.api.Test { response = h.yell_hello(new HelloRequest() { Name = "UnitTest 3" }); Assert.AreEqual("HELLO UNITTEST 3", response.Message); Assert.IsNotNull(last_update); - Assert.IsTrue(last_update.added.Count == 1); - Assert.IsTrue(last_update.removed.Count == 1); + Assert.IsTrue(last_update.added.Count() == 1); + Assert.IsTrue(last_update.removed.Count() == 1); Assert.IsTrue(last_update.state.Count == 1); Assert.IsTrue(last_update.state.Single().Value.Message == "HELLO UNITTEST 3"); last_update = null; @@ -108,8 +108,8 @@ namespace mbts.api.Test { _ntest.run_shout_service(null); response = h.yell_hello(new HelloRequest() { Name = "UnitTest 4" }); Assert.AreEqual("HELLO UNITTEST 4", response.Message); - Assert.IsTrue(last_update.added.Count == 1); - Assert.IsTrue(last_update.removed.Count == 1); + Assert.IsTrue(last_update.added.Count() == 1); + Assert.IsTrue(last_update.removed.Count() == 1); Assert.IsTrue(last_update.state.Count == 1); Assert.IsTrue(last_update.state.Single().Value.Message == "HELLO UNITTEST 4"); last_update = null; diff --git a/src/client/spark_test/api/ApiUpdateTests.cs b/src/client/spark_test/api/ApiUpdateTests.cs new file mode 100644 index 000000000..e9c28d5a2 --- /dev/null +++ b/src/client/spark_test/api/ApiUpdateTests.cs @@ -0,0 +1,231 @@ +using bts.api.core; +using System.Collections.Generic; +using bts.test; +using System; +using System.Reactive.Linq; +using System.Threading.Tasks; +using System.Linq; +using System.Reactive.Concurrency; + +namespace mbts.api.Test { + [TestGroup] + public class ApiUpdateTests { + int _id = 0; + List _item_pool; + + public ApiUpdateTests() { + // Generate a pool of items + _item_pool = Enumerable.Range(1, 50).Select(i => mkitem()).ToList(); + } + + class Item : IEquatable { + public Item(int id, string name) { + this.id = id; + this.name = name; + } + public int id { get; } + public string name { get; } + public override string ToString() => $"{id}-{name}"; + public override bool Equals(object obj) { + if (obj is Item i) { + return this.Equals(i); + } + return false; + } + public override int GetHashCode() { + return ToString().GetHashCode(); + } + + public bool Equals(Item other) { + return id == other.id && name == other.name; + } + } + static int id(Item i) => i.id; + + Item mkitem() { + return new Item(++_id, Guid.NewGuid().ToString().Substring(0,8)); + } + + IObservable> validate_incremental(IObservable> source) { + // strip the state from source and turn it back into a 'raw' update + // then use the (well tested) reconstitute function to re-build the state from the increments + return source.Select(u => { + var r = new RawUpdate(); + r.added_items.AddRange(u.added); + r.added_keys.AddRange(u.added.Select(id)); + r.changed_items.AddRange(u.changed); + r.changed_keys.AddRange(u.changed.Select(id)); + r.removed_keys.AddRange(u.removed.Select(id)); + return r; + }).reconstitute(id); + } + + async Task validate_naggle(IObservable> raw) { + var total = raw.ToEnumerable().Count(); + + // Validate that update is right at each point + // This will mostly be collapsing to add() + for (var count = 1; count < total; ++count) { + var orig = raw.Take(count).reconstitute(id).ToEnumerable().Last(); + var nag = await + validate_incremental( + raw + .Take(count) + .reconstitute(i => i.id) + .Naggle(TimeSpan.FromMilliseconds(1), CurrentThreadScheduler.Instance)).LastAsync(); + Assert.SequenceEqual(orig.all.OrderBy(id), nag.all.OrderBy(id)); + } + + // Do it again with TableUpdate + for (var count = 1; count < total; ++count) { + var orig = raw.Take(count).reconstitute(id).Table().ToEnumerable().Last(); + var nag = await + validate_incremental( + raw + .Take(count) + .reconstitute(i => i.id) + .Naggle(TimeSpan.FromMilliseconds(1), CurrentThreadScheduler.Instance)) + .Table() + .LastAsync(); + Assert.SequenceEqual(orig.state.Values.OrderBy(id), nag.state.Values.OrderBy(id)); + } + + // collapse rolling window + var update_list = raw.reconstitute(id).ToEnumerable().ToList(); + var window = 10; + for (int x = 0; x+window < total; x += 5) { + var start = update_list[x]; + var end = update_list[x + window]; + + var super_update = update_list.Skip(x).Take(window+1).Aggregate((u1, u2) => u1.merge(u2)); + start.merge(super_update); + Assert.SequenceEqual(end.all, super_update.all); + } + + } + + [Test] + public async Task test_add() { + // Add 1 item 10x + var raw = Observable.Create>(observer => { + RawUpdate rup = new RawUpdate(); + for (int x = 0; x < 50; ++x) { + rup.Clear(); + var item = _item_pool[x]; + rup.added_items.Add(item); + rup.added_keys.Add(item.id); + observer.OnNext(rup); + } + observer.OnCompleted(); + return Disposable.empty; + }); + + await validate_naggle(raw); + } + + [Test] + public Task test_remove() { + // Add 20 items, then remove 10 one at a time + var raw = Observable.Create>(observer => { + RawUpdate rup = new RawUpdate(); + // add 20 items + rup.added_items.AddRange(_item_pool.Take(20)); + rup.added_keys.AddRange(_item_pool.Take(20).Select(id)); + observer.OnNext(rup); + + for (int x = 0; x < 50; x+=2) { + rup.Clear(); + var item = _item_pool[x]; + rup.removed_keys.Add(item.id); + observer.OnNext(rup); + } + observer.OnCompleted(); + return Disposable.empty; + }); + + return validate_naggle(raw); + } + + [Test] + public Task test_update() { + // Add 20 items, then change all of their names to Taha + var raw = Observable.Create>(observer => { + RawUpdate rup = new RawUpdate(); + // add 20 items + rup.added_items.AddRange(_item_pool.Take(20)); + rup.added_keys.AddRange(_item_pool.Take(20).Select(id)); + observer.OnNext(rup); + + for (int x = 0; x < 20; x++) { + rup.Clear(); + var item = _item_pool[x]; + var item2 = new Item(item.id, "Taha"); + rup.changed_items.Add(item2); + rup.changed_keys.Add(item2.id); + observer.OnNext(rup); + } + observer.OnCompleted(); + return Disposable.empty; + }); + + return validate_naggle(raw); + } + + [Test] + public async Task test_random_walk() { + // Split items in half. + // Permute one collection in the direction of the other + var raw = Observable.Create>((observer) => { + Random r = new Random(42); + var even = _item_pool.Where(i => i.id % 2 == 0).Take(10).ToList(); + var odd = _item_pool.Where(i => i.id % 2 == 1).ToList(); + + RawUpdate rup = new RawUpdate(); + rup.added_items.AddRange(even); + rup.added_keys.AddRange(even.Select(i => i.id)); + observer.OnNext(rup); + + for (var x = 0; x < 200; ++x) { + rup = new RawUpdate(); + switch (r.Next(0, 3)) { + case 0: // add + if (odd.Count > 0) { + even.Add(odd[0]); + rup.added_items.Add(odd[0]); + rup.added_keys.Add(odd[0].id); + odd.RemoveAt(0); + observer.OnNext(rup); + } + break; + case 1: // remove + if (even.Count > 0) { + var item = r.choose(even); + even.Remove(item); + rup.removed_keys.Add(item.id); + observer.OnNext(rup); + } + break; + case 2: // change + if (even.Count > 0) { + var item = r.choose(even); + var item2 = new Item(item.id, "Jake"); + var index = even.IndexOf(item); + even[index] = item2; + rup.changed_items.Add(item2); + rup.changed_keys.Add(item2.id); + observer.OnNext(rup); + } + break; + } + } + + observer.OnCompleted(); + return Disposable.empty; + }); + + // Since this is deterministic randomness get the final collection + await validate_naggle(raw); + } + + } +} diff --git a/src/client/spark_test/api/SomeTests.cs b/src/client/spark_test/api/SomeTests.cs index 4b4602f7e..30c4ffcb5 100644 --- a/src/client/spark_test/api/SomeTests.cs +++ b/src/client/spark_test/api/SomeTests.cs @@ -6,8 +6,15 @@ using System.Threading.Tasks; namespace bts.test { //[TestGroup] - public class SomeTests { - // Tests for testing the tester + public class SomeTests : IDisposable { + SomeTests() { + // You can run common setup code here. + } + + public void Dispose() { + // Implement dispose if you need to clean up + } + [Test] public void test1() { Assert.IsTrue(true); diff --git a/src/client/spark_test/spark_test.csproj b/src/client/spark_test/spark_test.csproj index 1c2375581..1c755b687 100644 --- a/src/client/spark_test/spark_test.csproj +++ b/src/client/spark_test/spark_test.csproj @@ -3,6 +3,7 @@ net471 x64 + x64 diff --git a/src/lib/CMakeDeps.cmake b/src/lib/CMakeDeps.cmake index abaa78d5a..d84a00902 100644 --- a/src/lib/CMakeDeps.cmake +++ b/src/lib/CMakeDeps.cmake @@ -1 +1 @@ -set(sources api/apicore.proto;api/apigateway.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/service_helpers/AdminServiceUtils.cpp;api/services/AdminService.proto;api/services/ApiUnitTestService.proto;api/services/ErrorReportService.proto;api/services/HelloService.proto;api/services/MarketDataRelay.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/ShellDiagnosticService.proto;api/services/ShellLatencyService.proto;api/services/SyntheticSecurityService.proto;api/services/UserService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/Executor.conf;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/cpp_config.conf;config/defaults/edge.conf;config/defaults/expiration_display_offset.conf;config/defaults/jetfix.conf;config/defaults/logging.conf;config/defaults/orders_fills_cleanup.conf;config/defaults/testkeys.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/ExchangeSimCfg.proto;config/protos/MarketData.proto;config/protos/Ports.proto;config/protos/Symbols.proto;config/protos/UI.proto;config/protos/cpp_config.proto;config/protos/environment.proto;config/protos/expiration_display_offset.proto;config/protos/jetfix.proto;config/protos/logging.proto;config/protos/orders_fills_cleanup.proto;config/protos/quickbus_cfg.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/toggles.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain_model/Security.cpp;domain_model/Security.proto;domain_model/SecurityTests.cpp;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPriceLantencyTester.cpp;md/Diag/ShmDumper.cpp;md/MDConsumer.cpp;md/MDConsumerHandle.cpp;md/MDConsumerInterop.cpp;md/MDProducer.cpp;md/MDProducerHandle.cpp;md/MDRecoverableConsumer.cpp;md/MemorySegmentUtils.cpp;md/PlatformLoader.cpp;md/PriceSize.cpp;md/SecurityDB.cpp;md/SecurityIDRecorder.cpp;md/SettlementRecorder.cpp;md/Shm/FixedSecurity.cpp;md/SyntheticSecurityService.cpp;md/cme/MDP3Utils.cpp;md/common.cpp;md/protos/co2.proto;md/relay/QueryServer.cpp;md/relay/RelayClient.cpp;md/relay/RelayRecorder.cpp;md/test/Co2ManagedTestHelper.cpp;md/test/Co2TestInstrument.cpp;md/test/md2_tests.cpp;md/test/synthetic_book_merge_tests.cpp;os/os.cpp;os/tests/os_tests.cpp;quickbus/core/LocalNode.cpp;quickbus/core/Quickbus.cpp;quickbus/core/SubscriptionID.cpp;quickbus/core/TableID.cpp;quickbus/message_model/Update.cpp;quickbus/message_model/merge_updates.cpp;quickbus/network/QBConnection.cpp;quickbus/network/QBConnectionManager.cpp;quickbus/network/endpoint_description.cpp;quickbus/network/quickbus_msgs.proto;quickbus/pubsub/TablePublisher.cpp;quickbus/pubsub/TableSubscriber.cpp;quickbus/pubsub/tests/qb_pubsub_tests.cpp;quickbus/routing/INode.cpp;quickbus/routing/NodeID.cpp;quickbus/routing/Router.cpp;quickbus/rpc/RPCClient.cpp;quickbus/rpc/RPCServer.cpp;quickbus/rpc/RPCSessionID.cpp;quickbus/rpc/rpc_utils.cpp;quickbus/rpc/tests/qb_rpc_tests.cpp;quickbus/tests/quickbus_tests.cpp;sparkproto/SparkProtos.proto;testing/catch_test_runner.cpp;utils/Dispatcher.cpp;utils/HTTPStream.cpp;utils/PBUtils.cpp;utils/Puid.cpp;utils/SecureLogon.cpp;utils/SharedMemory.cpp;utils/Sqlite_utils.cpp;utils/Uuid.cpp;utils/datetime.cpp;utils/download.cpp;utils/file_utils.cpp;utils/init_spark_lib.cpp;utils/is_unittest_environment.cpp) \ No newline at end of file +set(sources api/apicore.proto;api/apigateway.proto;api/apioptions.proto;api/core/ApiClientInterop.cpp;api/core/ApiServerInterop.cpp;api/public/ApiServer.cpp;api/public/ClientChannel.cpp;api/public/QuickbusClientChannel.cpp;api/public/ServerChannel.cpp;api/public/ServiceContext.cpp;api/service_helpers/AdminServiceUtils.cpp;api/services/AdminService.proto;api/services/ApiUnitTestService.proto;api/services/ErrorReportService.proto;api/services/HelloService.proto;api/services/MarketDataRelay.proto;api/services/OrderService.proto;api/services/OutOfProcessURLListener.proto;api/services/PersistenceService.proto;api/services/PositionService.proto;api/services/ShellDiagnosticService.proto;api/services/ShellLatencyService.proto;api/services/SyntheticSecurityService.proto;api/services/UserService.proto;api/test/ApiTests.cpp;api/test/HelloServiceServer.cpp;config/ConfigCheck.cpp;config/ConfigDownloader.cpp;config/ConfigErrorCollector.cpp;config/ConfigLog.cpp;config/ConfigPropertyEvaluator.cpp;config/ConfigValueQueue.cpp;config/ConfigurationException.cpp;config/ConfigurationState.cpp;config/PreprocessInputStream.cpp;config/config.cpp;config/defaults/Executor.conf;config/defaults/MarketData.conf;config/defaults/Ports.conf;config/defaults/Symbols.conf;config/defaults/cpp_config.conf;config/defaults/edge.conf;config/defaults/expiration_display_offset.conf;config/defaults/jetfix.conf;config/defaults/logging.conf;config/defaults/orders_fills_cleanup.conf;config/defaults/testkeys.conf;config/defaults/toggles.conf;config/extensions/extensions.proto;config/invalid/invalid.proto;config/protos/ExchangeSimCfg.proto;config/protos/MarketData.proto;config/protos/Ports.proto;config/protos/Symbols.proto;config/protos/UI.proto;config/protos/cpp_config.proto;config/protos/environment.proto;config/protos/expiration_display_offset.proto;config/protos/jetfix.proto;config/protos/logging.proto;config/protos/orders_fills_cleanup.proto;config/protos/quickbus_cfg.proto;config/protos/system.proto;config/protos/testkeys.proto;config/protos/toggles.proto;config/tests/HTTPServer.cpp;config/tests/config_ref_tests.cpp;config/tests/config_tests.cpp;config/text_format/text_format.cpp;domain_model/Security.cpp;domain_model/Security.proto;domain_model/SecurityTests.cpp;expression/BooleanGrammar.cpp;expression/ExpressionEvaluator.cpp;expression/ParserExceptions.cpp;expression/Value.cpp;expression/tests/expression_parser_tests.cpp;logging/LoggerHub.cpp;logging/Sink.cpp;logging/logging.cpp;logging/tests/logging_tests.cpp;md/Diag/MDPriceLantencyTester.cpp;md/Diag/ShmDumper.cpp;md/MDConsumer.cpp;md/MDConsumerHandle.cpp;md/MDConsumerInterop.cpp;md/MDProducer.cpp;md/MDProducerHandle.cpp;md/MDRecoverableConsumer.cpp;md/MemorySegmentUtils.cpp;md/PlatformLoader.cpp;md/PriceSize.cpp;md/SecurityDB.cpp;md/SecurityIDRecorder.cpp;md/SettlementRecorder.cpp;md/Shm/FixedSecurity.cpp;md/SyntheticSecurityService.cpp;md/cme/MDP3Utils.cpp;md/common.cpp;md/protos/co2.proto;md/relay/QueryServer.cpp;md/relay/RelayClient.cpp;md/relay/RelayRecorder.cpp;md/test/Co2ManagedTestHelper.cpp;md/test/Co2TestInstrument.cpp;md/test/md2_tests.cpp;md/test/synthetic_book_merge_tests.cpp;os/os.cpp;os/tests/os_tests.cpp;quickbus/core/LocalNode.cpp;quickbus/core/Quickbus.cpp;quickbus/core/SubscriptionID.cpp;quickbus/core/TableID.cpp;quickbus/message_model/Update.cpp;quickbus/message_model/merge_updates.cpp;quickbus/network/QBConnection.cpp;quickbus/network/QBConnectionManager.cpp;quickbus/network/endpoint_description.cpp;quickbus/network/quickbus_msgs.proto;quickbus/pubsub/TablePublisher.cpp;quickbus/pubsub/TableSubscriber.cpp;quickbus/pubsub/tests/qb_pubsub_tests.cpp;quickbus/routing/INode.cpp;quickbus/routing/NodeID.cpp;quickbus/routing/Router.cpp;quickbus/rpc/RPCClient.cpp;quickbus/rpc/RPCServer.cpp;quickbus/rpc/RPCSessionID.cpp;quickbus/rpc/rpc_utils.cpp;quickbus/rpc/tests/qb_rpc_tests.cpp;quickbus/tests/quickbus_tests.cpp;sparkproto/SparkProtos.proto;testing/catch_test_runner.cpp;utils/Dispatcher.cpp;utils/HTTPStream.cpp;utils/PBUtils.cpp;utils/Puid.cpp;utils/SecureLogon.cpp;utils/SharedMemory.cpp;utils/Sqlite_utils.cpp;utils/Uuid.cpp;utils/datetime.cpp;utils/download.cpp;utils/file_utils.cpp;utils/init_spark_lib.cpp;utils/is_unittest_environment.cpp) \ No newline at end of file From 29fd10e57652df859c1772d024ef873a6eedb375 Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Tue, 21 Aug 2018 17:03:24 -0500 Subject: [PATCH 2/5] SPARK-1559 - Badges - hide orders whose DisplayStatus is set to hidden --- src/client/spark/view/Spark/Ladder/LadderVM.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/client/spark/view/Spark/Ladder/LadderVM.cs b/src/client/spark/view/Spark/Ladder/LadderVM.cs index c2e6151a6..15d22735b 100644 --- a/src/client/spark/view/Spark/Ladder/LadderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderVM.cs @@ -83,7 +83,7 @@ namespace mbts.spark { // Here we manage N orders to 1 price slot in the ladder Dictionary> orders_used_in_this_update = new Dictionary>(_equality); - var ladders_orders = working.Values.Where(o => o.Def.SecurityKey == security.Id); + var ladders_orders = working.Values.Where(o => o.Def.SecurityKey == security.Id && (o.HasState && o.State.DisplayStatus == OrderState.Types.DisplayStatus.Visible)); foreach (var wo in ladders_orders) { var slot_price_target = wo.price(); var order_type = wo.order_type(); From a763c54a339c1caed06213f25e8697b7f32a4494 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Tue, 21 Aug 2018 19:12:14 -0400 Subject: [PATCH 3/5] LadderSettingsView - replace margins with Row/ColumnDefinitions for spacing --- .../view/Spark/Ladder/LadderSettingsView.xaml | 31 +++++++++++++------ 1 file changed, 22 insertions(+), 9 deletions(-) diff --git a/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml b/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml index 8eeef5e1b..ddeb1f325 100644 --- a/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml +++ b/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml @@ -9,9 +9,17 @@ xmlns:cv="clr-namespace:mbts.ui.converters" xmlns:usp="clr-namespace:mbts.ui.spark" xmlns:txt="clr-namespace:mbts.ui.utility.text" + xmlns:sys="clr-namespace:System;assembly=mscorlib" TextElement.FontSize="{x:Static u:FontSizes.Small}" > + 4 + 8 + 8 + 24 + 4 + 6 + 8 @@ -62,20 +70,25 @@ + + + + - + - + + + - Order Badge Style - - Alternate Order Qty - - + Order Badge Style + + Alternate Order Qty + + @@ -148,7 +161,7 @@ - + From b5e6cfea8fcf3f1425a8dac9dddedd869521972d Mon Sep 17 00:00:00 2001 From: John Colvin Date: Tue, 21 Aug 2018 20:22:07 -0400 Subject: [PATCH 4/5] make EnumerableStringConverter more robust --- .../GenericCollectionExtensions.cs | 13 ++++++++ .../EnumerableDoubleStringConverter.cs | 6 ++-- .../EnumerableStringConverter.cs | 32 +++++++++---------- 3 files changed, 31 insertions(+), 20 deletions(-) diff --git a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs index fe5d4e1cd..aeb7db9fd 100644 --- a/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs +++ b/src/client/spark/core/GlobalExtensions/GenericCollectionExtensions.cs @@ -364,6 +364,19 @@ namespace System.Collections.Generic { if (condition) yield return get_value(); } + + /// + /// Uses to convert the elements of an to the specified type. + /// + /// The type to convert the elements of source to. + /// The that contains the elements to be cast to type + /// An that contains each element of the source sequence cast to the specified type. + /// is null. + public static IEnumerable convert(this IEnumerable source) { + ExceptionAssert.Argument.NotNull(source, nameof(source)); + foreach (object obj in source) + yield return ObjectHelper.try_convert(obj); + } } public static class CollectionExtensions diff --git a/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableDoubleStringConverter.cs b/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableDoubleStringConverter.cs index f320aae89..7d838bbee 100644 --- a/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableDoubleStringConverter.cs +++ b/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableDoubleStringConverter.cs @@ -1,9 +1,7 @@ using System; -namespace mbts.ui.converters -{ - public class EnumerableDoubleStringConverter : EnumerableStringConverter - { +namespace mbts.ui.converters { + class EnumerableDoubleStringConverter : EnumerableStringConverter { protected override double convert_item_back(string item_str) { double result; if (Double.TryParse(item_str, out result)) diff --git a/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableStringConverter.cs b/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableStringConverter.cs index 528bd176c..406e5f8cc 100644 --- a/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableStringConverter.cs +++ b/src/client/spark/view/Converters/EnumerableStringConverters/EnumerableStringConverter.cs @@ -1,26 +1,22 @@ using System; +using System.Collections; using System.Collections.Generic; using System.Linq; using System.Windows.Data; -namespace mbts.ui.converters -{ - public abstract class EnumerableStringConverter : IValueConverter - { - protected EnumerableStringConverter() { +namespace mbts.ui.converters { + abstract class EnumerableStringConverter : IValueConverter { + protected EnumerableStringConverter() => Separator = " "; - } public string Separator { get; set; } - protected virtual string convert_item(T item) { return item.ToString(); } - protected virtual T convert_item_back(string item_str) { throw new NotImplementedException(); } - public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { - if (value is IEnumerable) - return ((IEnumerable)value).Select(convert_item).list_string(Separator); - else - throw new ArgumentException("Expected 'Convert' input value to be {0}".fmt(typeof(IEnumerable))); + if (value is IEnumerable vals) { + return _format(vals); + } else if (value is IEnumerable ng_vals) { + return _format(ng_vals.convert()); + } else return value?.ToString(); } public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture) { @@ -33,9 +29,13 @@ namespace mbts.ui.converters } else throw new ArgumentException("Expected 'ConvertBack' input value to be {0}".fmt(typeof(string))); } + + protected virtual string convert_item(T item) { return item.ToString(); } + protected virtual T convert_item_back(string item_str) { throw new NotImplementedException(); } + + string _format(IEnumerable vals) => + string.Join(Separator, vals.Select(convert_item)); } - public class EnumerableStringConverter : EnumerableStringConverter - { - } + class EnumerableStringConverter : EnumerableStringConverter { } } From 6608bee39f9c0aafd2e2bf7e97c8e042443a8410 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Tue, 21 Aug 2018 21:12:13 -0400 Subject: [PATCH 5/5] SPARK-1544 Ability to change number pad quantities in Ladder --- .../ObservableEditableCollection.cs | 5 ++ .../spark/core/Utility/IPropertyWrapperVM.cs | 25 +++++++ .../spark/core/Utility/ViewModelBase.cs | 14 +++- .../view/Spark/Ladder/LadderSettingsVM.cs | 15 +++- .../view/Spark/Ladder/LadderSettingsView.xaml | 74 ++++++++++++++++++- 5 files changed, 127 insertions(+), 6 deletions(-) diff --git a/src/client/spark/core/Collections/ObservableEditableCollection.cs b/src/client/spark/core/Collections/ObservableEditableCollection.cs index 871689b17..5eb412eae 100644 --- a/src/client/spark/core/Collections/ObservableEditableCollection.cs +++ b/src/client/spark/core/Collections/ObservableEditableCollection.cs @@ -4,6 +4,11 @@ using System.Collections.ObjectModel; using System.Windows.Input; namespace mbts.collections { + static class ObservableEditableCollection { + public static ObservableEditableCollection create() where T : new() => + new ObservableEditableCollection(() => new T()); + } + class ObservableEditableCollection : ObservableCollection { public ObservableEditableCollection(Func factory, bool insert_new_item_at_front = false) { AddItemCommand = insert_new_item_at_front ? new DelegateCommand(() => Insert(0, factory())) : new DelegateCommand(() => Add(factory())); diff --git a/src/client/spark/core/Utility/IPropertyWrapperVM.cs b/src/client/spark/core/Utility/IPropertyWrapperVM.cs index 3a8d85d27..7de0096a9 100644 --- a/src/client/spark/core/Utility/IPropertyWrapperVM.cs +++ b/src/client/spark/core/Utility/IPropertyWrapperVM.cs @@ -5,6 +5,7 @@ using mbts.ui.utility; using System; using System.Collections.Generic; using System.Collections.ObjectModel; +using System.ComponentModel; using System.Linq; using System.Reactive.Linq; using System.Runtime.CompilerServices; @@ -30,6 +31,10 @@ namespace mbts.spark { void load_from(T value); } + interface IMutableValueWrapperVM : INotifyPropertyChanged { + T value { get; set; } + } + interface IViewValue { object value { get; } object view { get; } @@ -70,6 +75,12 @@ namespace mbts.spark { return vm; } + public static IMutableValueWrapperVM create_mutable_vm(T init = default) => + create_mutable_vm(EqualityComparer.Default, init); + + public static IMutableValueWrapperVM create_mutable_vm(IEqualityComparer comparer, T init = default) => + new MutableValueWrapperVM(comparer, init); + public static ITemplatedPropertyWrapperVM create_vm(string template_key, Func get, Action set, Dictionary> named_params = null) => new DelegatePropertyWrapperVM(template_key, get, set, named_params); @@ -88,6 +99,20 @@ namespace mbts.spark { public static IPropertyWrapperVM link(this IPropertyWrapperVM inner, Func get, Action set) => new LinkedPropertyWrapperVM(inner, get, set); + class MutableValueWrapperVM : ViewModelBase, IMutableValueWrapperVM { + readonly IEqualityComparer _comparer; + readonly Property _value; + + public MutableValueWrapperVM(IEqualityComparer comparer, T init) { + _comparer = comparer; + _value = backing(nameof(value), comparer, init); + } + + public T value { get => _value.Value; set => _value.set(value); } + + public override string ToString() => value?.ToString(); + } + class LinkedPropertyWrapperVM : ViewModelBase, IPropertyWrapperVM { readonly Func _get; readonly Action _set; diff --git a/src/client/spark/core/Utility/ViewModelBase.cs b/src/client/spark/core/Utility/ViewModelBase.cs index ec7195ef0..47a090dc8 100644 --- a/src/client/spark/core/Utility/ViewModelBase.cs +++ b/src/client/spark/core/Utility/ViewModelBase.cs @@ -113,8 +113,11 @@ namespace mbts.ui.shell protected delegate void PropertyChange(T oldval, T newval); // use nameof() to add compile time checks - protected Property backing(string name, T default_value = default(T)) { - return new Property(this, name, default_value); + protected Property backing(string name, T default_value = default(T)) => + backing(name, EqualityComparer.Default, default_value); + + protected Property backing(string name, IEqualityComparer comparer, T default_value = default(T)) { + return new Property(this, name, comparer, default_value); } protected Property backing(Expression> member, T default_value) { @@ -134,12 +137,17 @@ namespace mbts.ui.shell protected class Property : IObservable<(T oldval,T newval)> { readonly string _propname; + readonly IEqualityComparer _comparer; readonly ViewModelBase _owner; T _value; - public Property(ViewModelBase owner, string name, T default_value) { + public Property(ViewModelBase owner, string name, T default_value) + : this(owner, name, EqualityComparer.Default, default_value) { } + + public Property(ViewModelBase owner, string name, IEqualityComparer comparer, T default_value) { _owner = owner; _propname = name; + _comparer = comparer; _value = default_value; } diff --git a/src/client/spark/view/Spark/Ladder/LadderSettingsVM.cs b/src/client/spark/view/Spark/Ladder/LadderSettingsVM.cs index f117f8953..982e843e1 100644 --- a/src/client/spark/view/Spark/Ladder/LadderSettingsVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderSettingsVM.cs @@ -1,8 +1,8 @@ using bts.api; +using mbts.collections; using mbts.ui; using mbts.ui.controls.color_picker; using mbts.ui.shell; -using mbts.ui.spark; using System; using System.Collections.Generic; using System.Collections.ObjectModel; @@ -32,6 +32,8 @@ namespace mbts.spark { _session_range_fill = new LadderMarketBreakLineVM("Session Range", 0, 0, false); public LadderSettingsVM() { + size_presets = new ObservableEditableCollection>(_create_size_preset_vm); + size_presets.CollectionChanged += (s, e) => RaisePropertyChanged(nameof(size_presets_text)); _badge_style = backing(nameof(badge_style)); _badge_style.Changed += _badge_style_Changed; _alternate_order_size = backing(nameof(alternate_order_size)); @@ -81,6 +83,8 @@ namespace mbts.spark { public LadderColumnSettingsVM ask_column => _ask; public LadderColumnSettingsVM last_column => _last; public LadderMarketBreakLineVM session_range_fill => _session_range_fill; + public ObservableEditableCollection> size_presets { get; } + public string size_presets_text => string.Join(", ", size_presets); public IEnumerable mkt_break_items { get { @@ -97,6 +101,7 @@ namespace mbts.spark { _current = settings; badge_style = settings.badge_style; alternate_order_size = settings.alternate_order_size; + size_presets.SetItems(settings.calculator_buttons.empty_if_null().Select(s => _create_size_preset_vm((uint)s))); _orders.assign_from(_current.orders_column); _bid.assign_from(_current.bid_column); _ask.assign_from(_current.ask_column); @@ -114,6 +119,7 @@ namespace mbts.spark { var clone = SparkUtils.clone_proto(_current); clone.badge_style = badge_style; clone.alternate_order_size = alternate_order_size; + clone.calculator_buttons = size_presets.Select(vm => (int)vm.value).ToArray(); clone.orders_column = _orders.get_settings(); clone.bid_column = _bid.get_settings(); clone.price_column = _price.get_settings(); @@ -128,6 +134,13 @@ namespace mbts.spark { clone.row_height = LadderRender.measure_row_height(clone); return clone; } + + IMutableValueWrapperVM _create_size_preset_vm() => _create_size_preset_vm(0); + IMutableValueWrapperVM _create_size_preset_vm(uint init) { + var vm = PropertyWrapperVMUtils.create_mutable_vm(init); + vm.PropertyChanged += (s, e) => RaisePropertyChanged(nameof(size_presets_text)); + return vm; + } public class LadderColumnSettingsVM : ViewModelBase { readonly Property _font_size; diff --git a/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml b/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml index ddeb1f325..fa2b377ba 100644 --- a/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml +++ b/src/client/spark/view/Spark/Ladder/LadderSettingsView.xaml @@ -20,6 +20,7 @@ 4 6 8 + 24 @@ -69,6 +70,8 @@ + + @@ -86,9 +89,76 @@ Order Badge Style + Alternate Order Qty - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -161,7 +231,7 @@ - +