public IDisposable Initialize(IObservable<IConnected<IBroker>> brokerStream, IObservable<IConnected<IEventStoreConnection>> eventStore)
{
_cache = new TradeCache(eventStore);
_service = new BlotterService(_cache.GetTrades());
var disposable = brokerStream.LaunchOrKill(broker => new BlotterServiceHost(_service, broker)).Subscribe();
_cleanup.Add(disposable);
return disposable;
}
public AnalyticsServiceHost(IAnalyticsService service, IBroker broker, TradeCache tradeCache) : base(broker, "analytics")
{
_service = service;
_broker = broker;
_tradeCache = tradeCache;
_subscriptions = new CompositeDisposable();
RegisterCall("getAnalytics", GetAnalyticsStream);
StartHeartBeat();
ListenForPricesAndTrades();
}
public async Task StreamThrows()
{
var api = new Mock <IBinanceApi>().Object;
var client = new Mock <ITradeWebSocketClient>().Object;
var cache = new TradeCache(api, client);
using (var cts = new CancellationTokenSource())
{
await Assert.ThrowsAsync <ArgumentNullException>("symbol", () => cache.StreamAsync(null, cts.Token));
}
}
public void SubscribeThrows()
{
var symbol = Symbol.BTC_USDT;
var api = new Mock <IBinanceApi>().Object;
var client = new Mock <ITradeWebSocketClient>().Object;
var cache = new TradeCache(api, client);
Assert.Throws <ArgumentNullException>("symbol", () => cache.Subscribe(null));
Assert.Throws <ArgumentNullException>("symbol", () => cache.Subscribe(string.Empty));
cache.Subscribe(symbol);
Assert.Throws <InvalidOperationException>(() => cache.Subscribe(symbol));
}
public void TradeCache_AddTrades_GetLastTrades()
{
// Arrange
int incrementalSize = 5;
var tradeCache = new TradeCache <TestTradeCreator, TestTrade, TestTradeParameters>(incrementalSize);
var trade1 = new TestTrade {
Id = 1, Price = 0123m, Quantity = 1000m, Time = new DateTime(2000, 1, 1, 1, 0, 1)
};
var trade2 = new TestTrade {
Id = 2, Price = 0121m, Quantity = 500m, Time = new DateTime(2000, 1, 1, 1, 0, 2)
};
var trade3 = new TestTrade {
Id = 3, Price = 0124m, Quantity = 750m, Time = new DateTime(2000, 1, 1, 1, 0, 3)
};
// Act
tradeCache.Add(trade1);
tradeCache.Add(trade2);
tradeCache.Add(trade3);
var trades = tradeCache.GetTrades();
var lastTrade = tradeCache.GetLastTrade();
var lastTrades = tradeCache.GetLastTrades(3);
var lastTradesOver = tradeCache.GetLastTrades(4);
var lastTradesUnder = tradeCache.GetLastTrades(2);
// Assert
Assert.AreEqual(tradeCache.Position, 2);
Assert.AreEqual(tradeCache.CacheSize, 5);
Assert.AreEqual(tradeCache.TradeRange, 5);
Assert.AreEqual(trades.Length, 3);
Assert.AreEqual(lastTrade, trade3);
Assert.AreEqual(lastTrades.Length, 3);
Assert.AreEqual(lastTrades[0], trade1);
Assert.AreEqual(lastTrades[1], trade2);
Assert.AreEqual(lastTrades[2], trade3);
Assert.AreEqual(lastTradesOver.Length, 3);
Assert.AreEqual(lastTradesOver[0], trade1);
Assert.AreEqual(lastTradesOver[1], trade2);
Assert.AreEqual(lastTradesOver[2], trade3);
Assert.AreEqual(lastTradesUnder.Length, 2);
Assert.AreEqual(lastTradesUnder[0], trade2);
Assert.AreEqual(lastTradesUnder[1], trade3);
}
public void TradeCache_Initialise()
{
// Arrange
int incrementalSize = 5;
TradeCache <TestTradeCreator, TestTrade, TestTradeParameters> tradeCache;
// Act
tradeCache = new TradeCache <TestTradeCreator, TestTrade, TestTradeParameters>(incrementalSize);
// Assert
Assert.AreEqual(tradeCache.Position, -1);
Assert.AreEqual(tradeCache.TradeRange, 5);
Assert.AreEqual(tradeCache.CacheSize, incrementalSize);
Assert.IsNull(tradeCache.GetLastTrade());
Assert.IsNull(tradeCache.GetTrades());
Assert.IsNull(tradeCache.GetLastTrades(1));
Assert.IsNull(tradeCache.GetLastTrades(5));
}
static void Construct()
{
LrpClient = CreateLocalClient(Signature.Value, "SoftFX.LlApi.");
LrpLlCommonClient = CreateLocalClient(Financial.Generated.Signature.Value, "SoftFX.LlCommon.");
Serializer = new Financial.Generated.Serializer(LrpLlCommonClient);
Handle = new Handle(LrpClient);
Params = new Params(LrpClient);
Client = new ClientServer(LrpClient);
ClientCache = new ClientCache(LrpClient);
FeedServer = new FeedServer(LrpClient);
FeedCache = new FeedCache(LrpClient);
TradeServer = new TradeServer(LrpClient);
TradeCache = new TradeCache(LrpClient);
Converter = new Converter(LrpClient);
TradeHistoryIterator = new TradeHistoryIterator(LrpClient);
DailySnapshotsIterator = new DailySnapshotsIterator(LrpClient);
Library = new Library(LrpClient);
}
public Task SubscribeTrades(string symbol, int limit, Action <TradeEventArgs> callback, Action <Exception> exception, CancellationToken cancellationToken)
{
var tcs = new TaskCompletionSource <object>();
try
{
var tradeCache = new TradeCache(binanceApi, new TradeWebSocketClient());
tradeCache.Subscribe(symbol, limit, e =>
{
if (cancellationToken.IsCancellationRequested)
{
tradeCache.Unsubscribe();
return;
}
try
{
var trades = e.Trades.Select(t => NewTrade(t)).ToList();
callback.Invoke(new TradeEventArgs {
Trades = trades
});
}
catch (Exception ex)
{
tradeCache.Unsubscribe();
exception.Invoke(ex);
return;
}
});
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
return(tcs.Task);
}
public override async Task <bool> TryUpdateStrategyAsync(string parameters)
{
var tcs = new TaskCompletionSource <bool>();
try
{
var strategyParameters = JsonConvert.DeserializeObject <MovingAverageTradeParameters>(parameters);
if (tradeCache == null)
{
tradeCache = new TradeCache <MovingAverageTradeCreator, MovingAverageTrade, MovingAverageTradeParameters>(strategyParameters.TradeRange);
}
if (movingAverageTradeParameters == null ||
!strategyParameters.MovingAvarageRange.Equals(movingAverageTradeParameters.MovingAvarageRange) ||
!strategyParameters.SellIndicator.Equals(movingAverageTradeParameters.SellIndicator) ||
!strategyParameters.BuyIndicator.Equals(movingAverageTradeParameters.BuyIndicator))
{
movingAverageTradeParameters = strategyParameters;
tradeCache.TradeCreator.Reset(movingAverageTradeParameters);
}
suspend = movingAverageTradeParameters.Suspend;
StrategyNotification(new StrategyNotificationEventArgs {
StrategyNotification = new StrategyNotification {
Name = Strategy.Name, Message = $"Parameter update : {parameters}", NotificationLevel = NotificationLevel.Information
}
});
tcs.SetResult(true);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
return(await tcs.Task);
}
public void LinkToClient()
{
var api = new Mock <IBinanceApi>().Object;
var client1 = new Mock <ITradeClient>().Object;
var client2 = new TradeClient();
var symbol1 = Symbol.BTC_USDT;
var symbol2 = Symbol.LTC_BTC;
client2.Subscribe(symbol1);
var clientSubscribeStreams = client2.SubscribedStreams.ToArray();
Assert.Equal(TradeClient.GetStreamName(symbol1), clientSubscribeStreams.Single());
var cache = new TradeCache(api, client1)
{
Client = client2 // link client.
};
// Client subscribed streams are unchanged after link to unsubscribed cache.
Assert.Equal(clientSubscribeStreams, client2.SubscribedStreams);
cache.Client = client1; // unlink client.
// Subscribe cache to symbol.
cache.Subscribe(symbol2);
// Cache is subscribed to symbol.
Assert.Equal(TradeClient.GetStreamName(symbol2), cache.SubscribedStreams.Single());
cache.Client = client2; // link to client.
// Client has second subscribed stream from cache.
Assert.True(client2.SubscribedStreams.Count() == 2);
Assert.Contains(TradeClient.GetStreamName(symbol2), client2.SubscribedStreams);
}
public IDisposable Initialize(IObservable <IConnected <IBroker> > brokerStream, IObservable <IConnected <IEventStoreConnection> > eventStoreStream)
{
_cache = new TradeCache(eventStoreStream);
_service = new BlotterService(_cache.GetTrades());
return(brokerStream.LaunchOrKill(broker => new BlotterServiceHost(_service, broker)).Subscribe());
}
static void Construct()
{
LrpClient = CreateLocalClient(Signature.Value, "SoftFX.LlApi.");
LrpLlCommonClient = CreateLocalClient(Financial.Generated.Signature.Value, "SoftFX.LlCommon.");
Serializer = new Financial.Generated.Serializer(LrpLlCommonClient);
Handle = new Handle(LrpClient);
Params = new Params(LrpClient);
Client = new ClientServer(LrpClient);
ClientCache = new ClientCache(LrpClient);
FeedServer = new FeedServer(LrpClient);
FeedCache = new FeedCache(LrpClient);
TradeServer = new TradeServer(LrpClient);
TradeCache = new TradeCache(LrpClient);
Converter = new Converter(LrpClient);
Iterator = new Iterator(LrpClient);
Library = new Library(LrpClient);
}
