Files
spark/src/client/spark_api/md/MarketDataClient.cs
T

285 lines
10 KiB
C#

using System;
using System.Linq;
using System.Collections.Generic;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
using System.Reactive.Linq;
using System.Reactive.Concurrency;
using System.Reactive.Subjects;
using bts.api;
using bts.api.core;
using bts.co2;
namespace bts.api.md
{
using security_key = System.UInt32;
public class MarketDataClient : IDisposable
{
class Data
{
public long last_update_time;
public ChannelUpdate data;
}
readonly ConcurrentDictionary<security_key, Data> _data = new ConcurrentDictionary<security_key, Data>();
readonly ConcurrentDictionary<security_key, string> _security_names = new ConcurrentDictionary<security_key, string>();
readonly static Lazy<MarketDataRelay> _md = new Lazy<MarketDataRelay>(() => locate(), true);
readonly Lazy<MDRequest> _subscription = new Lazy<MDRequest>(() => load_request());
private MarketDataClient()
{
}
public static MarketDataClient create()
{
return new MarketDataClient();
}
static MDRequest load_request()
{
var req = new MDRequest();
var prods = _md.Value.request_products(new VoidMessage()).Products;
foreach(var prod in prods)
req.Channels.Add(new SecurityChannel() { Exchange = prod.Exchange, Type = prod.Type, Symbol = prod.Symbol, Flags = 0 });
return req;
}
static MarketDataRelay locate()
{
using (var ctx = new api.core.ServiceContext())
{
return ctx.locate<MarketDataRelay>();
}
}
public Security lookup(security_key key)
{
Data value;
if(_data.TryGetValue(key, out value))
return value.data.Security;
else
return null;
}
public string lookup_security_name(security_key key)
{
_security_names.TryGetValue(key, out string value);
return value;
}
public Security find_security(Func<Security, bool> filter)
{
return _data.Values.Select(x => x.data.Security).Where(xx => filter(xx)).FirstOrDefault();
}
public async Task<Security> find_security_async(Func<Security, bool> filter, TimeSpan? timeout = null)
{
if(!timeout.HasValue)
timeout = TimeSpan.FromMilliseconds(int.MaxValue-1);
CancellationTokenSource src = new CancellationTokenSource(timeout.Value);
Security security = await Task.Run<Security>(async () =>
{
Security sec = null;
do
{
sec = find_security(filter);
if (sec == null)
await Task.Delay(500);
}
while (sec == null);
return sec;
}, src.Token);
return security ?? throw new KeyNotFoundException("Can't find security for filter"); ;
}
public IObservable<ChannelUpdate> subscribe(Product product,
TimeSpan? update_interval = null, IScheduler scheduler = null)
{
return subscribe(product,
(System.UInt32)(MDRequest.Types.Flags.Security | MDRequest.Types.Flags.Bbo |
MDRequest.Types.Flags.Depth | MDRequest.Types.Flags.LastTrade),
update_interval, scheduler);
}
public IObservable<ChannelUpdate> subscribe(Product product, uint flags,
TimeSpan? update_interval = null, IScheduler scheduler = null)
{
check_subscriptions(flags, x =>
(x.Exchange == product.Exchange && x.Type == product.Type && x.Symbol == product.Symbol));
return _subscribe(
x => (x.Exchange == product.Exchange && ((SecurityImmutable)x).security_type() == product.Type && x.Symbol == product.Symbol),
update_interval,
scheduler);
}
IObservable<ChannelUpdate> _subscribe(Func<Security, bool> filter,
TimeSpan? update_interval = null, IScheduler scheduler = null)
{
Data[] slots = new Data[0]; long local_security_count = 0;
return timer_pump<Data>((last_update, observer) =>
{
//if the number of securities has changed, or this is the first call
if (slots.Length == 0 || local_security_count != _data.Count)
slots = _data.Values.Where(xx => filter(xx.data.Security)).ToArray();
foreach (var slot in slots)
{
Data data;
if (_data.TryGetValue(slot.data.Security.Id, out data))
{
if (data.last_update_time > last_update)
observer.OnNext(data);
}
}
},
update_interval, scheduler).Select(x => x.data);
}
/// <summary>
/// Poll for updates for a security on a specified update_interval, on the specified scheduler with default flags
/// </summary>
/// <param name="security"></param>
/// <param name="update_interval"></param>
/// <param name="scheduler"></param>
/// <returns></returns>
public IObservable<ChannelUpdate> subscribe(Security security,
TimeSpan? update_interval = null, IScheduler scheduler = null)
{
return subscribe(security,
(System.UInt32)(MDRequest.Types.Flags.Security | MDRequest.Types.Flags.Bbo |
MDRequest.Types.Flags.Depth | MDRequest.Types.Flags.LastTrade),
update_interval, scheduler);
}
/// <summary>
/// Poll for updates for a security on a specified update_interval, on the specified scheduler
/// </summary>
/// <param name="security"></param>
/// <param name="flags"></param>
/// <param name="update_interval"></param>
/// <param name="scheduler"></param>
/// <returns></returns>
public IObservable<ChannelUpdate> subscribe(Security security, uint flags,
TimeSpan? update_interval = null, IScheduler scheduler = null)
{
check_subscriptions(flags, x =>
(x.Exchange == security.Exchange && x.Type == ((SecurityImmutable)security).security_type() && security.Symbol == security.Symbol));
return timer_pump<Data>( (last_update, observer) =>
{
Data data;
if (_data.TryGetValue(security.Id, out data))
{
if (data.last_update_time > last_update)
observer.OnNext(data);
}
},
update_interval, scheduler).Select(x => x.data);
}
IObservable<T> timer_pump<T>(Action<long, IObserver<T>> tick, TimeSpan? interval, IScheduler scheduler = null)
{
if(!interval.HasValue)
interval = TimeSpan.FromMilliseconds(25);
long last_update_time = 0;
return Observable.Create<T>(observer =>
{
return Observable.Timer(interval.Value, interval.Value, scheduler ?? Scheduler.Default).Subscribe(_ =>
{
tick(last_update_time, observer);
last_update_time = DateTime.UtcNow.Ticks;
});
});
}
bool check_subscriptions(uint flags, Func<SecurityChannel, bool> selector)
{
foreach (var sub in _subscription.Value.Channels)
{
if (selector(sub))
{
sub.Flags |= flags;
return true;
}
}
return false;
}
/// <summary>
/// Start pumping market data for all subscribed channels and securities. Call this without await
/// </summary>
/// <param name="interval"></param>
/// <returns></returns>
public async Task start_pump(TimeSpan? interval = null)
{
var rep = await _md.Value.request_names_async(new VoidMessage()); int count = 0;
do
{
foreach (var s in rep.value.Securities)
foreach (var ss in s.Names)
_security_names[ss.Key] = ss.Value;
}
while (!rep.success && count++ < 5);
while (true)
{
var reply = await _md.Value.requestmd_async(_subscription.Value);
if (reply.success)
{
foreach (var channel in reply.value.Channels)
{
long now = DateTime.UtcNow.Ticks;
foreach (var update in channel.Updates)
{
Data data;
if (_data.TryGetValue(update.Security.Id, out data))
{
//mergefrom concats repeated fields
if (update.Book != null)
data.data.Book = null;
//this can tear, but the book won't tear, so maybe it's ok
data.data.MergeFrom(update);
data.last_update_time = now;
}
else
{
_data[update.Security.Id] = new Data() { last_update_time = now, data = update };
}
}
}
await Task.Delay(interval ?? TimeSpan.FromMilliseconds(100), _cts.Token);
}
}
}
Task _pump_task;
public void run_pump(TimeSpan? interval = null)
{
if (_pump_task == null)
{
_pump_task = this.start_pump(interval)
.ContinueWith(ex =>
{
System.Diagnostics.Debug.Assert(ex == null, ex.ToString());
}
, TaskContinuationOptions.OnlyOnFaulted);
}
}
public async void run_pump_async(TimeSpan? interval = null)
{
await this.start_pump(interval);
}
readonly CancellationTokenSource _cts = new CancellationTokenSource();
public void Dispose()
{
_cts.Cancel();
_cts.Dispose();
if (_md.IsValueCreated)
_md.Value.Dispose();
}
}
}