diff --git a/src/DataStreamSuite/DataStreamCore/DynamicLoading/LiveMarketDataStreamAttribute.cs b/src/DataStreamSuite/DataStreamCore/DynamicLoading/LiveMarketDataStreamAttribute.cs
new file mode 100644
index 000000000..595cd94cc
--- /dev/null
+++ b/src/DataStreamSuite/DataStreamCore/DynamicLoading/LiveMarketDataStreamAttribute.cs
@@ -0,0 +1,5 @@
+namespace Bts.DataStreamCore;
+
+using System;
+
+public class LiveMarketDataStreamAttribute : Attribute { }
diff --git a/src/DataStreamSuite/DataStreamCore/DynamicLoading/MarketDataClientParamAttribute.cs b/src/DataStreamSuite/DataStreamCore/DynamicLoading/MarketDataClientParamAttribute.cs
new file mode 100644
index 000000000..2e826301f
--- /dev/null
+++ b/src/DataStreamSuite/DataStreamCore/DynamicLoading/MarketDataClientParamAttribute.cs
@@ -0,0 +1,5 @@
+namespace Bts.DataStreamCore;
+
+using System;
+
+public class MarketDataClientParamAttribute : Attribute { }
diff --git a/src/DataStreamSuite/DataStreamCore/DynamicLoading/MarketDataStreamFactory.cs b/src/DataStreamSuite/DataStreamCore/DynamicLoading/MarketDataStreamFactory.cs
new file mode 100644
index 000000000..a4b68b872
--- /dev/null
+++ b/src/DataStreamSuite/DataStreamCore/DynamicLoading/MarketDataStreamFactory.cs
@@ -0,0 +1,49 @@
+#nullable enable
+namespace Bts.DataStreamCore;
+
+using BCG;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+
+///
+/// This class is a temp hack to pass a shared md client to stream constructors.
+///
+public class MarketDataStreamFactory {
+ readonly object mdClient;
+
+ public MarketDataStreamFactory(object mdClient) =>
+ this.mdClient = mdClient;
+
+ public ViewStream? Create(Type type, object?[]? args) {
+ var ctrs = type.GetConstructors();
+ int nArgs = args?.Length ?? 0;
+ // Since this class is a temp hack, it isn't super robust. Find a constructor with nArgs + 1
+ // or 2 params (for mdClient and optional viewStreamDatabase), inject the special args and
+ // instantiate the stream. If no such constructor exists, just use the original args.
+ foreach (var ctr in ctrs) {
+ var ctrParams = ctr.GetParameters();
+ if (!ctrParams.TryGetFirst(p => p!.GetCustomAttribute() is not null, out var mdClientParam, out int mdClientIdx)) {
+ continue;
+ }
+ var paramInjections = new List<(int Index, object Value)>(2) {
+ (mdClientIdx, mdClient)
+ };
+ if (ctrParams.TryGetFirst(p => p.ParameterType == typeof(ViewStreamDatabase), out var vsdParam, out int vsdIdx)) {
+ paramInjections.Add((vsdIdx, ViewStreamDatabase.instance));
+ }
+ if (nArgs != ctrParams.Length - paramInjections.Count) {
+ continue;
+ }
+ paramInjections.Sort(Comparer<(int, object)>.Create((a, b) => a.Item1.CompareTo(b.Item1)));
+ var argList = args?.ToList() ?? new();
+ foreach (var (idx, val) in paramInjections) {
+ argList.Insert(idx, val);
+ }
+ return Activator.CreateInstance(type, argList.ToArray()) as ViewStream;
+ }
+ return Activator.CreateInstance(type, args) as ViewStream;
+ }
+}
diff --git a/src/DataStreamSuite/DataStreamCore/DynamicLoading/PrimitiveManager.cs b/src/DataStreamSuite/DataStreamCore/DynamicLoading/PrimitiveManager.cs
index 8d392318d..a889290cb 100644
--- a/src/DataStreamSuite/DataStreamCore/DynamicLoading/PrimitiveManager.cs
+++ b/src/DataStreamSuite/DataStreamCore/DynamicLoading/PrimitiveManager.cs
@@ -8,8 +8,10 @@ namespace BCG {
using System.Collections;
using System.Reflection;
using System.IO;
+ using Bts.DataStreamCore;
public class PrimitiveManager {
+ static MarketDataStreamFactory mdStreamFactory;
private IDictionary myTypeLookupTable = new Hashtable();
private static PrimitiveManager mySelf;
private ArrayList myAssemblyNames = new ArrayList();
@@ -99,6 +101,11 @@ namespace BCG {
get { return mySelf = mySelf == null ? new PrimitiveManager() : mySelf; }
}
+ public static void SetMarketDataClient(object value) {
+ Log.isnull(mdStreamFactory);
+ mdStreamFactory = new(value);
+ }
+
///
/// Returns the Type name corresponding to the primitive name
///
@@ -123,12 +130,19 @@ namespace BCG {
constructorArgs = new object[args.Count];
args.CopyTo(constructorArgs, 0);
}
- if (myTypeLookupTable[friendlyName] == null)
- throw new ApplicationException(friendlyName + " is not the friendly name of any of the loaded types");
+ var type = myTypeLookupTable[friendlyName] as Type
+ ?? throw new ApplicationException(friendlyName + " is not the friendly name of any of the loaded types");
+ if (type.HasCustomAttribute()) {
+ if (mdStreamFactory is null) {
+ Log.Gen.error("Live md not available for streams");
+ return null;
+ }
+ return mdStreamFactory.Create(type, constructorArgs);
+ }
return
constructorArgs == null ?
- Activator.CreateInstance(myTypeLookupTable[friendlyName] as Type) as ViewStream :
- Activator.CreateInstance(myTypeLookupTable[friendlyName] as Type, constructorArgs) as ViewStream;
+ Activator.CreateInstance(type) as ViewStream :
+ Activator.CreateInstance(type, constructorArgs) as ViewStream;
}
///
diff --git a/src/DataStreamSuite/DataStreamCore/ViewStreamDatabase.cs b/src/DataStreamSuite/DataStreamCore/ViewStreamDatabase.cs
index a314b308b..b691c107a 100644
--- a/src/DataStreamSuite/DataStreamCore/ViewStreamDatabase.cs
+++ b/src/DataStreamSuite/DataStreamCore/ViewStreamDatabase.cs
@@ -9,9 +9,10 @@ using System.Threading;
using mbts;
using System.Linq;
using System.Diagnostics;
+using Bts.PubSub;
namespace BCG {
- public class ViewStreamDatabase : IWorker, IDisposable {
+ public class ViewStreamDatabase : IWorker, IWorkScheduler, IDisposable {
internal delegate void TagFireDelegate(string tag);
public delegate void DoWorkDelegate();
private event DoWorkDelegate onDoWorkStart,
@@ -211,7 +212,9 @@ namespace BCG {
else
_workers.Add(w);
}
-
+ void IWorkScheduler.Add(IWorker worker, TimeSpan interval) =>
+ // TODO: respect the interval param
+ addWorker(worker);
public void removeWorker(IWorker w) {
verifyAccess();
@@ -220,6 +223,8 @@ namespace BCG {
else
_workers.Remove(w);
}
+ void IWorkScheduler.Remove(IWorker worker) =>
+ removeWorker(worker);
#region IDisposable Members
diff --git a/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs b/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs
index 6d8b90596..12713c7e1 100644
--- a/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs
+++ b/src/DataStreamSuite/DataStreamQueryAnalyzer/Program.cs
@@ -2,6 +2,7 @@ using BCG;
using bts;
using bts.api.core;
+using bts.md;
using Bts.DataStreamQueryAnalyzer;
using Bts.PubSub;
@@ -26,6 +27,7 @@ static class Program {
cfg.MergeWith(DataStreamQueryAnalyzerConfig.Default());
PubSubConfig.SetGlobalConfig(Log.notnull(cfg.PubSub));
Configuration.initialize(cfg.Sparkd);
+ PrimitiveManager.SetMarketDataClient(new MarketDataClient(new(TimeSpan.FromSeconds(0.5))));
Log.Gen.info("Starting DataStreamQueryAnalyzer");
var mainForm = new MainForm();
if (cfg.StreamFile is not null) {
diff --git a/src/DataStreamSuite/PubSub/Misc/AnonymousWorker.cs b/src/DataStreamSuite/PubSub/Misc/AnonymousWorker.cs
new file mode 100644
index 000000000..9d49e81ba
--- /dev/null
+++ b/src/DataStreamSuite/PubSub/Misc/AnonymousWorker.cs
@@ -0,0 +1,15 @@
+namespace Bts.PubSub;
+
+using BCG.Utilities.General;
+
+using System;
+
+public class AnonymousWorker : IWorker {
+ readonly Action work;
+
+ public AnonymousWorker(Action work) =>
+ this.work = work;
+
+ public void doWork() =>
+ work();
+}
diff --git a/src/DataStreamSuite/PubSub/Misc/IParameterizedWorker.cs b/src/DataStreamSuite/PubSub/Misc/IParameterizedWorker.cs
new file mode 100644
index 000000000..2a255ebb8
--- /dev/null
+++ b/src/DataStreamSuite/PubSub/Misc/IParameterizedWorker.cs
@@ -0,0 +1,10 @@
+namespace Bts.PubSub;
+
+using BCG.Utilities.General;
+
+using System;
+
+public interface IParameterizedWorker : IWorker {
+ string? Group => null;
+ TimeSpan Interval => TimeSpan.Zero;
+}
diff --git a/src/DataStreamSuite/PubSub/Misc/IWorkScheduler.cs b/src/DataStreamSuite/PubSub/Misc/IWorkScheduler.cs
new file mode 100644
index 000000000..da8a09601
--- /dev/null
+++ b/src/DataStreamSuite/PubSub/Misc/IWorkScheduler.cs
@@ -0,0 +1,10 @@
+namespace Bts.PubSub;
+
+using BCG.Utilities.General;
+
+using System;
+
+public interface IWorkScheduler {
+ void Add(IWorker worker, TimeSpan interval);
+ void Remove(IWorker worker);
+}
diff --git a/src/DataStreamSuite/PubSub/Misc/WorkScheduler.cs b/src/DataStreamSuite/PubSub/Misc/WorkScheduler.cs
new file mode 100644
index 000000000..d9d8fca20
--- /dev/null
+++ b/src/DataStreamSuite/PubSub/Misc/WorkScheduler.cs
@@ -0,0 +1,87 @@
+namespace Bts.PubSub;
+
+using BCG.Utilities.General;
+
+using bts;
+using bts.collections;
+using bts.utils;
+
+using Spark.Core.Threading;
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+
+public class WorkScheduler : IWorkScheduler, IDisposable {
+ readonly AtomicGate gate = new();
+ WorkerData[] workers = Array.Empty();
+ int isDisposed;
+ int cursor;
+
+ public WorkScheduler(bool isBackground, int numThreads, TimeSpan interval) {
+ numThreads = Math.Max(1, numThreads);
+ var threads = new Thread[numThreads];
+ for (int i = 0; i < numThreads; i++) {
+ threads[i] = new Thread(WorkLoop) {
+ IsBackground = isBackground
+ };
+ threads[i].Start();
+ }
+
+ void WorkLoop() {
+ while (Volatile.Read(ref isDisposed) == 0) {
+ var workers = Volatile.Read(ref this.workers);
+ if (workers.Length == 0) {
+ continue;
+ }
+ int cursor = (Interlocked.Increment(ref this.cursor) - 1) % workers.Length;
+ int origin = cursor;
+ do {
+ var w = workers[cursor];
+ if (Interlocked.CompareExchange(ref w.IsBusy, 1, 0) == 0) {
+ if ((DateTime.Now - w.LastWorkTime) < w.Interval) {
+ Log.assert(Interlocked.CompareExchange(ref w.IsBusy, 0, 1) == 1);
+ continue;
+ }
+ w.Worker.doWork();
+ w.LastWorkTime = DateTime.Now;
+ Log.assert(Interlocked.CompareExchange(ref w.IsBusy, 0, 1) == 1);
+ break;
+ }
+ cursor = (Interlocked.Increment(ref this.cursor) - 1) % workers.Length;
+ } while (cursor != origin);
+ Thread.Sleep(interval);
+ }
+ }
+ }
+
+ public void Add(IWorker worker, TimeSpan interval) {
+ using var _ = gate.BeginTransaction();
+ workers = ArrayHelper.add(workers, new(worker, interval));
+ }
+
+ public void Remove(IWorker worker) {
+ using var _ = gate.BeginTransaction();
+ if (workers.WrapSelector(w => w.Worker, null).TryFindIndex(worker, out var i)) {
+ ArrayHelper.remove_at(ref workers, i);
+ }
+ }
+
+ public void Dispose() =>
+ Volatile.Write(ref isDisposed, 1);
+
+ class WorkerData {
+ public readonly IWorker Worker;
+ public readonly TimeSpan? Interval;
+ // 1 means busy, 0 means not busy (would be a bool if Interlocked.CompareExchange
+ // had an overload that accepted them).
+ public int IsBusy;
+ public DateTime LastWorkTime = DateTime.MinValue;
+
+ public WorkerData(IWorker worker, TimeSpan? interval) {
+ Worker = worker;
+ Interval = interval;
+ }
+ }
+}
+
diff --git a/src/DataStreamSuite/PubSub/Misc/WorkSchedulerExtensions.cs b/src/DataStreamSuite/PubSub/Misc/WorkSchedulerExtensions.cs
new file mode 100644
index 000000000..7232356e4
--- /dev/null
+++ b/src/DataStreamSuite/PubSub/Misc/WorkSchedulerExtensions.cs
@@ -0,0 +1,39 @@
+namespace Bts.PubSub;
+
+using BCG.Utilities.General;
+
+using Spark.Core.Disposables;
+
+using System;
+
+public static class WorkSchedulerExtensions {
+ public static void Add(this IWorkScheduler scheduler, IWorker worker) =>
+ scheduler.Add(worker, (worker as IParameterizedWorker)?.Interval ?? TimeSpan.Zero);
+
+ ///
+ /// Invoke an action (once) on an IWorkScheduler callback.
+ ///
+ /// The scheduler on which to invoke the action
+ /// The action to invoke
+ public static void Post(this IWorkScheduler scheduler, Action action) {
+ AnonymousWorker? worker = null;
+ worker = new AnonymousWorker(DoWork);
+ scheduler.Add(worker);
+
+ void DoWork() {
+ scheduler.Remove(worker!);
+ action();
+ }
+ }
+
+ public static IDisposable Subscribe(this IWorkScheduler scheduler, IWorker worker, TimeSpan? interval = null) {
+ scheduler.Add(worker, interval ?? TimeSpan.Zero);
+ return Disposable.Create(Dispose);
+ void Dispose() =>
+ scheduler.Remove(worker);
+ }
+
+ public static IDisposable Subscribe(this IWorkScheduler scheduler, Action work, TimeSpan? interval = null) =>
+ scheduler.Subscribe(new AnonymousWorker(work), interval);
+}
+
diff --git a/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/BookSchemaBuilder.cs b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/BookSchemaBuilder.cs
new file mode 100644
index 000000000..87ba6daef
--- /dev/null
+++ b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/BookSchemaBuilder.cs
@@ -0,0 +1,152 @@
+namespace Bts.SharedStreams.MarketData;
+
+using BCG;
+
+using bts.api;
+using bts.md;
+
+using Bts.DataStream;
+using Bts.DataStreamCore;
+
+using Spark.Api.MarketData;
+
+public class BookSchemaBuilder {
+ public int NumLevels { get; set; } = 5;
+ public bool ShowVenue { get; set; } = true;
+ public bool ShowAsset { get; set; } = true;
+ public bool ShowSecurityType { get; set; } = true;
+ public bool ShowSecurityName { get; set; } = true;
+ public bool ShowSecurityId { get; set; } = true;
+ public bool ShowCashPerPoint { get; set; } = true;
+ public bool ShowPrice { get; set; } = true;
+ public bool ShowQuantity { get; set; } = true;
+ public bool ShowNotional { get; set; } = true;
+ public string TableName { get; set; } = "Book";
+
+ public IBlueTableSchema ToSchema() {
+ var bd = new BlueTableSchemaBuilder(TableName) {
+ ("id", typeof(int))
+ };
+ if (ShowVenue) {
+ bd.Add(WellKnownColumns.Venue);
+ }
+ if (ShowAsset) {
+ bd.Add(WellKnownColumns.Asset);
+ }
+ if (ShowSecurityType) {
+ bd.Add(WellKnownColumns.SecurityType);
+ }
+ if (ShowSecurityName) {
+ bd.Add(WellKnownColumns.SecurityName);
+ }
+ if (ShowSecurityId) {
+ bd.Add(WellKnownColumns.SecurityId);
+ }
+ if (ShowCashPerPoint) {
+ bd.Add(WellKnownColumns.CashPerPoint);
+ }
+ foreach (var side in new[] { Side.Buy, Side.Sell }) {
+ for (int i = 0; i < NumLevels; i++) {
+ if (ShowPrice) {
+ bd.Add(WellKnownColumns.DepthPrice(side, i));
+ }
+ if (ShowQuantity) {
+ bd.Add(WellKnownColumns.DepthQuantity(side, i));
+ }
+ if (ShowNotional) {
+ bd.Add(WellKnownColumns.DepthNotional(side, i));
+ }
+ }
+ }
+ return bd.ToSchema();
+ }
+
+ public BlueTableSchemaAdapter BookTupleAdapter() {
+ var adapter = new BlueTableSchemaAdapter(TableName);
+ adapter.AddColumn("id", r => (int)r.security_id);
+ if (ShowVenue) {
+ adapter.AddColumn(WellKnownColumns.Venue.Name, b => b.security.Exchange.ToString());
+ }
+ if (ShowAsset) {
+ adapter.AddColumn(WellKnownColumns.Asset.Name, b => b.security.Symbol);
+ }
+ if (ShowSecurityType) {
+ adapter.AddColumn(WellKnownColumns.SecurityType.Name, b => b.security.security_type().ToString());
+ }
+ if (ShowSecurityName) {
+ adapter.AddColumn(WellKnownColumns.SecurityName.Name, b => b.security.ToString());
+ }
+ if (ShowSecurityId) {
+ adapter.AddColumn(WellKnownColumns.SecurityId.Name, b => b.security_id);
+ }
+ if (ShowCashPerPoint) {
+ adapter.AddColumn(WellKnownColumns.CashPerPoint.Name, b => b.security.ContractSpec.CashPerPoint);
+ }
+ foreach (var side in new[] { Side.Buy, Side.Sell }) {
+ for (int i = 0; i < NumLevels; i++) {
+ if (ShowPrice) {
+ adapter.AddColumn(WellKnownColumns.DepthPrice(side, i).Name, priceGetter(side, i));
+ }
+ if (ShowQuantity) {
+ adapter.AddColumn(WellKnownColumns.DepthQuantity(side, i).Name, quantityGetter(side, i));
+ }
+ if (ShowNotional) {
+ adapter.AddColumn(WellKnownColumns.DepthNotional(side, i).Name, notionalGetter(side, i));
+ }
+ }
+ }
+ return adapter;
+ }
+
+ public BlueTableSchemaAdapter BboAdapter() {
+ var adapter = new BlueTableSchemaAdapter(TableName);
+ adapter.AddColumn("id", r => (int)r.security_id);
+ if (ShowVenue) {
+ adapter.AddColumn(WellKnownColumns.Venue.Name, b => b.security.Exchange.ToString());
+ }
+ if (ShowAsset) {
+ adapter.AddColumn(WellKnownColumns.Asset.Name, b => b.security.Symbol);
+ }
+ if (ShowSecurityType) {
+ adapter.AddColumn(WellKnownColumns.SecurityType.Name, b => b.security.security_type().ToString());
+ }
+ if (ShowSecurityName) {
+ adapter.AddColumn(WellKnownColumns.SecurityName.Name, b => b.security.ToString());
+ }
+ if (ShowSecurityId) {
+ adapter.AddColumn(WellKnownColumns.SecurityId.Name, b => b.security_id);
+ }
+ if (ShowCashPerPoint) {
+ adapter.AddColumn(WellKnownColumns.CashPerPoint.Name, b => b.security.ContractSpec.CashPerPoint);
+ }
+ if (ShowPrice) {
+ adapter.AddColumn(WellKnownColumns.BidPrice.Name, b => b.book.bids[0].price);
+ }
+ if (ShowQuantity) {
+ adapter.AddColumn(WellKnownColumns.BidQuantity.Name, b => b.book.bids[0].size);
+ }
+ if (ShowNotional) {
+ adapter.AddColumn(WellKnownColumns.BidNotional.Name, b => b.book.bids[0].NotionalValue(b.security.ContractSpec.CashPerPoint));
+ }
+ if (ShowPrice) {
+ adapter.AddColumn(WellKnownColumns.AskPrice.Name, b => b.book.asks[0].price);
+ }
+ if (ShowQuantity) {
+ adapter.AddColumn(WellKnownColumns.AskQuantity.Name, b => b.book.asks[0].size);
+ }
+ if (ShowNotional) {
+ adapter.AddColumn(WellKnownColumns.AskNotional.Name, b => b.book.asks[0].NotionalValue(b.security.ContractSpec.CashPerPoint));
+ }
+ return adapter;
+ }
+
+ static Func priceGetter(Side side, int level) =>
+ b => b.book[side, level].price;
+
+ static Func quantityGetter(Side side, int level) =>
+ b => b.book[side, level].size;
+
+ static Func notionalGetter(Side side, int level) =>
+ b => b.book[side, level].NotionalValue(b.security.ContractSpec.CashPerPoint);
+}
+
diff --git a/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/BookStreamParams.cs b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/BookStreamParams.cs
new file mode 100644
index 000000000..040d8e0e2
--- /dev/null
+++ b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/BookStreamParams.cs
@@ -0,0 +1,66 @@
+namespace Bts.SharedStreams.MarketData;
+
+using bts.api;
+
+using System.Text.RegularExpressions;
+
+public class BookStreamParams {
+ public Venue? Venue { get; set; }
+ public string? Asset { get; set; }
+ public SecurityType? SecurityType { get; set; }
+ public string? Name { get; set; }
+ public string? NameOrAsset { get; set; }
+ public string? SecurityName { get; set; }
+ public int NumLevels { get; set; } = 5;
+ public bool ShowVenue { get; set; } = true;
+ public bool ShowAsset { get; set; } = true;
+ public bool ShowSecurityType { get; set; } = true;
+ public bool ShowSecurityName { get; set; } = true;
+ public bool ShowSecurityId { get; set; } = true;
+ public bool ShowCashPerPoint { get; set; } = true;
+ public bool ShowPrice { get; set; } = true;
+ public bool ShowQuantity { get; set; } = true;
+ public bool ShowNotional { get; set; } = true;
+
+ public Func GetSecurityFilter() {
+ var nameRx = CreateRegex(Name);
+ var nameOrAssetRx = CreateRegex(NameOrAsset);
+ return SecurityFilter;
+
+ static Regex? CreateRegex(string? pattern) =>
+ pattern is null ? null : new(pattern);
+
+ bool SecurityFilter(SecurityImmutable s) {
+ if (Venue.HasValue && Venue.Value != s.Exchange) {
+ return false;
+ }
+ if (SecurityType.HasValue && SecurityType != s.security_type()) {
+ return false;
+ }
+ if (Asset is not null && Asset != s.Symbol) {
+ return false;
+ }
+ if (nameRx is not null && !nameRx.IsMatch(s.ToString()!)) {
+ return false;
+ }
+ if (nameOrAssetRx is not null && NameOrAsset != s.Symbol && !nameOrAssetRx.IsMatch(s.ToString()!)) {
+ return false;
+ }
+ return true;
+ }
+ }
+
+ public BookSchemaBuilder GetSchemaBuilder() =>
+ new() {
+ NumLevels = NumLevels,
+ ShowVenue = ShowVenue,
+ ShowAsset = ShowAsset,
+ ShowSecurityType = ShowSecurityType,
+ ShowSecurityName = ShowSecurityName,
+ ShowSecurityId = ShowSecurityId,
+ ShowCashPerPoint = ShowCashPerPoint,
+ ShowPrice = ShowPrice,
+ ShowQuantity = ShowQuantity,
+ ShowNotional = ShowNotional,
+ };
+}
diff --git a/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/Live/LiveBBOStream.cs b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/Live/LiveBBOStream.cs
index 7fe3f7adf..4b73a2c48 100644
--- a/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/Live/LiveBBOStream.cs
+++ b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/Live/LiveBBOStream.cs
@@ -1,26 +1,35 @@
-namespace bts.BlueOrb
- {
- using System;
-
+namespace bts.BlueOrb {
using BCG;
- using bts.api;
+ using bts.md;
+ using Bts.DataStream;
+ using Bts.DataStreamCore;
+ using Bts.SharedStreams.MarketData;
+
+ [LiveMarketDataStream]
[DataStreamUserRespresentation("LiveBBOStream")]
public class LiveBBOStream : ViewStream {
- public LiveBBOStream(string target)
- : this(SecurityType.Future, target) { }
- public LiveBBOStream(SecurityType sec_type, string target) {
- ViewStream rs = null;
- switch (sec_type) {
- case SecurityType.Future:
- rs = new LiveFuturesBBOStream(target);
- break;
- default:
- Log.assert(false);
- break;
+ public LiveBBOStream([MarketDataClientParam] MarketDataClient mdClient, ViewStreamDatabase vsd)
+ : this(mdClient, vsd, null, null, null) { }
+
+ public LiveBBOStream([MarketDataClientParam] MarketDataClient mdClient, ViewStreamDatabase vsd, string? venueStr, string? nameOrAsset)
+ : this(mdClient, vsd, venueStr, null, nameOrAsset) { }
+
+ public LiveBBOStream([MarketDataClientParam] MarketDataClient mdClient, ViewStreamDatabase vsd, string? venueStr, string? secTypeStr, string? nameOrAsset) {
+ var opts = new BookStreamParams() {
+ NameOrAsset = nameOrAsset,
+ };
+ if (VenueArgumentParser.TryParse(venueStr, out var venue)) {
+ opts.Venue = venue;
}
- mySetRealSource(rs);
+ if (SecurityTypeArgumentParser.TryParse(secTypeStr, out var secType)) {
+ opts.SecurityType = secType;
+ }
+ var schemaBd = opts.GetSchemaBuilder();
+ var adapter = schemaBd.BboAdapter();
+ var secFilter = opts.GetSecurityFilter();
+ mySetRealSource(mdClient.books(secFilter).AsDataPackets(adapter).OnWorkScheduler(vsd).AsViewStream());
}
}
}
diff --git a/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/SecurityTypeArgumentParser.cs b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/SecurityTypeArgumentParser.cs
new file mode 100644
index 000000000..6e309041f
--- /dev/null
+++ b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/SecurityTypeArgumentParser.cs
@@ -0,0 +1,23 @@
+namespace Bts.SharedStreams.MarketData;
+
+using bts.api;
+
+public static class SecurityTypeArgumentParser {
+ public static bool TryParse(string? str, out SecurityType result) {
+ if (str is null) {
+ result = SecurityType.Unset;
+ return false;
+ }
+ if (Enum.TryParse(str, true, out result) || Enum.TryParse("SECURITYTYPE_" + str, true, out result)) {
+ return true;
+ }
+ result = str.ToUpper() switch {
+ "F" or "FUT" or "FUTURE" => SecurityType.Future,
+ "O" or "OPT" or "OPTION" => SecurityType.Option,
+ "SPOT" or "STOCK" => SecurityType.Spot,
+ "SPD" or "SPREAD" or "COMBO" => SecurityType.Spread,
+ _ => SecurityType.Unset,
+ };
+ return result != SecurityType.Unset;
+ }
+}
diff --git a/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/VenueArgumentParser.cs b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/VenueArgumentParser.cs
new file mode 100644
index 000000000..6b6642cc8
--- /dev/null
+++ b/src/DataStreamSuite/SharedStreams/BlueOrb/MarketData/VenueArgumentParser.cs
@@ -0,0 +1,21 @@
+namespace Bts.SharedStreams.MarketData;
+
+using bts.api;
+
+public static class VenueArgumentParser {
+ public static bool TryParse(string? str, out Venue result) {
+ if (str is null) {
+ result = Venue.Unset;
+ return false;
+ }
+ if (Enum.TryParse(str, true, out result) || Enum.TryParse("VENUE_" + str, true, out result)) {
+ return true;
+ }
+ result = str.ToUpper() switch {
+ "CME" or "XCME" or "CEC" or "XCEC" => Venue.Glbx,
+ "CBOT" or "CBT" or "XCBT" => Venue.Cboe,
+ _ => Venue.Unset,
+ };
+ return result != Venue.Unset;
+ }
+}
diff --git a/src/DataStreamSuite/SharedStreams/BlueOrb/WellKnownColumns.cs b/src/DataStreamSuite/SharedStreams/BlueOrb/WellKnownColumns.cs
new file mode 100644
index 000000000..f69461d67
--- /dev/null
+++ b/src/DataStreamSuite/SharedStreams/BlueOrb/WellKnownColumns.cs
@@ -0,0 +1,69 @@
+namespace Bts.SharedStreams;
+
+using bts.api;
+
+using Spark.Api.Orders;
+
+public static class WellKnownColumns {
+ public static (string Name, Type Type) AskNotional => (WellKnownColumnNames.AskNotional, typeof(double));
+ public static (string Name, Type Type) AskPrice => (WellKnownColumnNames.AskPrice, typeof(double));
+ public static (string Name, Type Type) AskQuantity => (WellKnownColumnNames.AskQuantity, typeof(double));
+ public static (string Name, Type Type) Asset => (WellKnownColumnNames.Asset, typeof(string));
+ public static (string Name, Type Type) BidNotional => (WellKnownColumnNames.BidNotional, typeof(double));
+ public static (string Name, Type Type) BidPrice => (WellKnownColumnNames.BidPrice, typeof(double));
+ public static (string Name, Type Type) BidQuantity => (WellKnownColumnNames.BidQuantity, typeof(double));
+ public static (string Name, Type Type) CashPerPoint => (WellKnownColumnNames.CashPerPoint, typeof(double));
+ public static (string Name, Type Type) Price => (WellKnownColumnNames.Price, typeof(double));
+ public static (string Name, Type Type) Quantity => (WellKnownColumnNames.Quantity, typeof(double));
+ public static (string Name, Type Type) SecurityId => (WellKnownColumnNames.SecurityId, typeof(uint));
+ public static (string Name, Type Type) SecurityName => (WellKnownColumnNames.SecurityName, typeof(string));
+ public static (string Name, Type Type) SecurityType => (WellKnownColumnNames.SecurityType, typeof(string));
+ public static (string Name, Type Type) Timestamp => (WellKnownColumnNames.Timestamp, typeof(DateTime));
+ public static (string Name, Type Type) Venue => (WellKnownColumnNames.Venue, typeof(string));
+
+ public static (string Name, Type Type) DepthNotional(Side side, int level) => (WellKnownColumnNames.DepthNotional(side, level), typeof(double));
+ public static (string Name, Type Type) DepthPrice(Side side, int level) => (WellKnownColumnNames.DepthPrice(side, level), typeof(double));
+ public static (string Name, Type Type) DepthQuantity(Side side, int level) => (WellKnownColumnNames.DepthQuantity(side, level), typeof(double));
+
+ public static (string Name, Type Type) LegAsset(int legNum) => (WellKnownColumnNames.LegAsset(legNum), typeof(string));
+ public static (string Name, Type Type) LegCashPerPoint(int legNum) => (WellKnownColumnNames.LegCashPerPoint(legNum), typeof(double));
+ public static (string Name, Type Type) LegExpiration(int legNum) => (WellKnownColumnNames.LegExpiration(legNum), typeof(DateTime));
+ public static (string Name, Type Type) LegSecurityId(int legNum) => (WellKnownColumnNames.LegSecurityId(legNum), typeof(uint));
+ public static (string Name, Type Type) LegSecurityName(int legNum) => (WellKnownColumnNames.LegSecurityName(legNum), typeof(string));
+ public static (string Name, Type Type) LegSecurityType(int legNum) => (WellKnownColumnNames.LegSecurityType(legNum), typeof(string));
+ public static (string Name, Type Type) LegVenue(int legNum) => (WellKnownColumnNames.LegVenue(legNum), typeof(string));
+}
+
+public static class WellKnownColumnNames {
+ public const string AskNotional = "ask_notl";
+ public const string AskPrice = "ask_price";
+ public const string AskQuantity = "ask_qty";
+ public const string Asset = "asset";
+ public const string BidNotional = "bid_notl";
+ public const string BidPrice = "bid_price";
+ public const string BidQuantity = "bid_qty";
+ public const string CashPerPoint = "cpp";
+ public const string Currency = "currency";
+ public const string Expiration = "exp";
+ public const string NumLegs = "num_legs";
+ public const string Price = "price";
+ public const string Quantity = "qty";
+ public const string SecurityId = "sec_id";
+ public const string SecurityName = "sec_name";
+ public const string SecurityType = "sec_type";
+ public const string Timestamp = "ts_event";
+ public const string TradingStatus = "trd_status";
+ public const string Venue = "venue";
+
+ public static string DepthNotional(Side side, int level) => $"{side.BidAskNameLower()}_notl_{level}";
+ public static string DepthPrice(Side side, int level) => $"{side.BidAskNameLower()}_price_{level}";
+ public static string DepthQuantity(Side side, int level) => $"{side.BidAskNameLower()}_qty_{level}";
+
+ public static string LegAsset(int legNum) => $"leg_{legNum}_{Asset}";
+ public static string LegCashPerPoint(int legNum) => $"leg_{legNum}_{CashPerPoint}";
+ public static string LegExpiration(int legNum) => $"leg_{legNum}_{Expiration}";
+ public static string LegSecurityId(int legNum) => $"leg_{legNum}_{SecurityId}";
+ public static string LegSecurityName(int legNum) => $"leg_{legNum}_{SecurityName}";
+ public static string LegSecurityType(int legNum) => $"leg_{legNum}_{SecurityType}";
+ public static string LegVenue(int legNum) => $"leg_{legNum}_{Venue}";
+}
diff --git a/src/client/spark_api/MarketData/Book.cs b/src/client/spark_api/MarketData/Book.cs
index ab1e2ca92..39b1db1d1 100644
--- a/src/client/spark_api/MarketData/Book.cs
+++ b/src/client/spark_api/MarketData/Book.cs
@@ -1,4 +1,5 @@
namespace bts.md {
+ using bts.api;
using bts.api.core;
using mbts;
@@ -21,9 +22,19 @@ namespace bts.md {
public List bids { get; }
public List asks { get; }
+ public List this[Side side] =>
+ side switch {
+ Side.Buy => bids,
+ Side.Sell => asks,
+ _ => throw new ArgumentException("Invalid side", nameof(side)),
+ };
+
public static Book empty(uint security_id) =>
new(security_id, new(0), new(0));
+ public PriceSize this[Side side, int level] =>
+ this[side][level];
+
public bool Equals(Book other) =>
security_id == other.security_id &&
bids.SequenceEqual(other.bids) &&
diff --git a/src/client/spark_api/MarketData/PriceSize.cs b/src/client/spark_api/MarketData/PriceSize.cs
index 1ae86e123..42d04c3af 100644
--- a/src/client/spark_api/MarketData/PriceSize.cs
+++ b/src/client/spark_api/MarketData/PriceSize.cs
@@ -41,4 +41,9 @@ namespace bts.md {
public override int GetHashCode() =>
HashCode.Combine(size, direct_size, implied_size, price);
}
+
+ public static class PriceSizeExtensions {
+ public static double NotionalValue(this PriceSize priceSize, double cashPerPoint) =>
+ priceSize.price * priceSize.size * cashPerPoint;
+ }
}
diff --git a/src/client/spark_api/Orders/OrdersExtensions.cs b/src/client/spark_api/Orders/OrdersExtensions.cs
index f2c7b1669..c326e65ff 100644
--- a/src/client/spark_api/Orders/OrdersExtensions.cs
+++ b/src/client/spark_api/Orders/OrdersExtensions.cs
@@ -394,6 +394,20 @@ namespace Spark.Api.Orders {
return false;
}
+ public static string BidAskName(this Side side) =>
+ side switch {
+ Side.Buy => "Bid",
+ Side.Sell => "Ask",
+ _ => side.ToString(),
+ };
+
+ public static string BidAskNameLower(this Side side) =>
+ side switch {
+ Side.Buy => "bid",
+ Side.Sell => "ask",
+ _ => side.ToString().ToLower(),
+ };
+
// public static Brush badge_fill(AlgoDefinitionMetadata? algo_meta, OrderMetadata order_meta) =>
// new SolidColorBrush(badge_color(algo_meta, order_meta));
diff --git a/src/client/spark_api_server/Program.cs b/src/client/spark_api_server/Program.cs
index 429c4cb77..9af427a31 100644
--- a/src/client/spark_api_server/Program.cs
+++ b/src/client/spark_api_server/Program.cs
@@ -15,6 +15,7 @@
using System.Reactive.Linq;
using System.Threading.Tasks;
using System.Threading;
+ using bts.md;
class Program {
[Flags]
@@ -39,6 +40,7 @@
PubSubConfig.SetGlobalConfig(Log.notnull(opts.PubSub));
var service_ctx = ServiceContext.create(opts.sparkd);
await service_ctx.login(opts.user, opts.password);
+ PrimitiveManager.SetMarketDataClient(new MarketDataClient(new(TimeSpan.FromSeconds(0.5))));
var sync = new bts.websocket_core.WebsocketDataSync(service_ctx);
var gwy = new bts.websocket_core.WebsocketConnectionGateway();
diff --git a/src/client/spark_core/Threading/AtomicGate.cs b/src/client/spark_core/Threading/AtomicGate.cs
new file mode 100644
index 000000000..c3218c133
--- /dev/null
+++ b/src/client/spark_core/Threading/AtomicGate.cs
@@ -0,0 +1,156 @@
+#nullable enable
+namespace Spark.Core.Threading;
+
+using bts;
+
+using Spark.Core.Disposables;
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+public class AtomicGate {
+ const int maxAttemptsBeforeSleep = 32;
+ static readonly int[] increasingSleeps = new[] { 1, 10, 100, 200, 500, 1000 };
+ static int idCounter = 0;
+
+ readonly string name;
+ readonly int id = Interlocked.Increment(ref idCounter);
+ readonly object syncRoot = new();
+ int versionIn = 0;
+ int versionOut = 0;
+
+ public AtomicGate(string? name = null) =>
+ this.name = name ?? string.Empty;
+
+ public bool IsBusy => Volatile.Read(ref versionIn) != Volatile.Read(ref versionOut);
+
+ public void Enter() {
+ int n;
+ for (n = 0; n < maxAttemptsBeforeSleep; n++) {
+ if (TryEnter()) {
+ return;
+ }
+ Thread.Yield();
+ }
+ for (n = 0; n < increasingSleeps.Length; n++) {
+ if (TryEnter()) {
+ return;
+ }
+ sleep(increasingSleeps[n]);
+ }
+ while (!TryEnter()) {
+ sleep(increasingSleeps[^1]);
+ }
+ }
+
+ public bool TryEnter() {
+ // var vin = Volatile.Read(ref versionIn);
+ // var vout = Volatile.Read(ref versionOut);
+ // Log.DataFlow.diag($$"""[atomic_gate_try_entering.json]{ "id": {{id}}, "name": "{{name}}", "vin": {{vin}}, "vout": {{vout}}, "ts": "{{DateTime.Now}}" }""");
+ bool res = Impl();
+ // vin = Volatile.Read(ref versionIn);
+ // vout = Volatile.Read(ref versionOut);
+ // Log.DataFlow.diag($$"""[atomic_gate_try_entered.json]{ "id": {{id}}, "name": "{{name}}", "vin": {{vin}}, "vout": {{vout}}, "res": {{res}}, "ts": "{{DateTime.Now}}" }""");
+ return res;
+
+ bool Impl() {
+ lock (syncRoot) {
+ if (versionIn == versionOut) {
+ versionIn++;
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+
+ public void Execute(Action action) {
+ Enter();
+ try {
+ action();
+ } finally {
+ Exit();
+ }
+ }
+
+ public bool TryExecute(Action action) {
+ if (!TryEnter()) {
+ return false;
+ }
+ try {
+ action();
+ } finally {
+ Exit();
+ }
+ return true;
+ }
+
+ public async Task TryExecuteAsync(Func asyncAction) {
+ if (!TryEnter()) {
+ return false;
+ }
+ try {
+ await asyncAction();
+ } finally {
+ Exit();
+ }
+ return true;
+ }
+
+ public async Task<(bool Executed, T? Result)> TryExecuteAsync(Func> asyncAction) {
+ if (!TryEnter()) {
+ return (false, default);
+ }
+ T? res;
+ try {
+ res = await asyncAction();
+ } finally {
+ Exit();
+ }
+ return (true, res);
+ }
+
+ public IDisposable BeginTransaction() {
+ int version = Interlocked.Increment(ref versionIn) - 1;
+ int n = 0;
+ var end = Disposable.Create(EndTransaction);
+ for (n = 0; n < maxAttemptsBeforeSleep; n++) {
+ if (Volatile.Read(ref versionOut) == version) {
+ return end;
+ }
+ Thread.Yield();
+ }
+ for (n = 0; n < increasingSleeps.Length; n++) {
+ if (Volatile.Read(ref versionOut) == version) {
+ return end;
+ }
+ sleep(increasingSleeps[n], version);
+ }
+ while (Volatile.Read(ref versionOut) != version) {
+ sleep(increasingSleeps[^1], version);
+ }
+ return end;
+
+ void EndTransaction() =>
+ Log.assert(Interlocked.CompareExchange(ref versionOut, version + 1, version) == version);
+ }
+
+ public Task BeginTransactionAsync() =>
+ Task.Run(BeginTransaction);
+
+ public void Exit() {
+ lock (syncRoot) {
+ Log.assert(versionIn == versionOut + 1);
+ versionOut = versionIn;
+ }
+ }
+
+ void sleep(int sleepMillis, int? version = null) {
+ // var vout = Volatile.Read(ref versionOut);
+ // var vin = Volatile.Read(ref versionIn);
+ // Log.DataFlow.warn($$"""[atomic_gate_sleep.json]{ "id": {id}, "name": "{{name}}", "vin": {vin}, "vout": {{vout}}, "v": {{version}}, "dur": {{sleepMillis}}ms, "ts": "{{DateTime.Now}}" }""");
+ Thread.Sleep(sleepMillis);
+ }
+}
+