protected override async ValueTask <TradeCacheEventArgs> OnAction(TradeEventArgs @event)
{
// If trades have not been initialized or are out-of-sync (gap in data).
while (_trades.Count == 0 || @event.Trade.Id > _trades.Last().Id + 1)
{
if (_trades.Count > 0)
{
OutOfSync?.Invoke(this, EventArgs.Empty);
}
await SynchronizeTradesAsync(_symbol, _limit, @event.Token)
.ConfigureAwait(false);
}
// Ignore trades older than the latest trade in queue.
if (@event.Trade.Id <= _trades.Last().Id)
{
Logger?.LogDebug($"{nameof(TradeCache)} ({_symbol}): Ignoring event (trade ID: {@event.Trade.Id}). [thread: {Thread.CurrentThread.ManagedThreadId}{(@event.Token.IsCancellationRequested ? ", canceled" : string.Empty)}]");
return(null);
}
lock (_sync)
{
var removed = _trades.Dequeue();
Logger?.LogDebug($"{nameof(TradeCache)} ({_symbol}): REMOVE trade (ID: {removed.Id}). [thread: {Thread.CurrentThread.ManagedThreadId}{(@event.Token.IsCancellationRequested ? ", canceled" : string.Empty)}]");
_trades.Enqueue(@event.Trade);
Logger?.LogDebug($"{nameof(TradeCache)} ({_symbol}): ADD trade (ID: {@event.Trade.Id}). [thread: {Thread.CurrentThread.ManagedThreadId}{(@event.Token.IsCancellationRequested ? ", canceled" : string.Empty)}]");
}
return(new TradeCacheEventArgs(_trades.ToArray()));
}
protected override async ValueTask <AggregateTradeCacheEventArgs> OnAction(AggregateTradeEventArgs @event)
{
var synchronize = false;
// If trades have not been initialized or are out-of-sync (gap in data).
lock (_sync)
{
if (_trades.Count == 0 || @event.Trade.Id > _trades.Last().Id + 1)
{
if (_trades.Count > 0)
{
OutOfSync?.Invoke(this, EventArgs.Empty);
}
synchronize = true;
}
}
if (synchronize)
{
await SynchronizeTradesAsync(_symbol, _limit, @event.Token)
.ConfigureAwait(false);
}
lock (_sync)
{
if (_trades.Count == 0 || @event.Trade.Id > _trades.Last().Id + 1)
{
Logger?.LogError($"{nameof(AggregateTradeCache)} ({_symbol}): Failed to synchronize trades. [thread: {Thread.CurrentThread.ManagedThreadId}]");
return(null);
}
// Ignore trades older than the latest trade in queue.
if (@event.Trade.Id <= _trades.Last().Id)
{
Logger?.LogDebug($"{nameof(AggregateTradeCache)} ({_symbol}): Ignoring event (trade ID: {@event.Trade.Id}). [thread: {Thread.CurrentThread.ManagedThreadId}]");
return(null);
}
var removed = _trades.Dequeue();
Logger?.LogTrace($"{nameof(AggregateTradeCache)} ({_symbol}): REMOVE aggregate trade (ID: {removed.Id}). [thread: {Thread.CurrentThread.ManagedThreadId}]");
_trades.Enqueue(@event.Trade);
Logger?.LogTrace($"{nameof(AggregateTradeCache)} ({_symbol}): ADD aggregate trade (ID: {@event.Trade.Id}). [thread: {Thread.CurrentThread.ManagedThreadId}]");
return(new AggregateTradeCacheEventArgs(_trades.ToArray()));
}
}
/// <summary>
///
/// </summary>
/// <param name="event"></param>
/// <returns></returns>
protected override async ValueTask <OrderBookCacheEventArgs> OnAction(DepthUpdateEventArgs @event)
{
if (_limit > 0)
{
// Ignore events with same or earlier order book update.
if (_orderBookClone != null && @event.LastUpdateId <= _orderBookClone.LastUpdateId)
{
Logger?.LogDebug($"{nameof(OrderBookCache)} ({_symbol}): Ignoring event (last update ID: {@event.LastUpdateId}). [thread: {Thread.CurrentThread.ManagedThreadId}{(@event.Token.IsCancellationRequested ? ", canceled" : string.Empty)}]");
return(null);
}
// Top <limit> bids and asks, pushed every second.
// NOTE: LastUpdateId is not contiguous between events when using partial depth stream.
_orderBookClone = new OrderBook(_symbol, @event.LastUpdateId, @event.Bids, @event.Asks);
}
else
{
// If order book has not been initialized or is out-of-sync (gap in data).
while (_orderBook == null || @event.FirstUpdateId > _orderBook.LastUpdateId + 1)
{
if (_orderBook != null)
{
OutOfSync?.Invoke(this, EventArgs.Empty);
}
// Synchronize.
await SynchronizeOrderBookAsync(@event.Token)
.ConfigureAwait(false);
}
// Ignore events prior to order book snapshot.
if (@event.LastUpdateId <= _orderBook.LastUpdateId)
{
Logger?.LogDebug($"{nameof(OrderBookCache)} ({_symbol}): Ignoring event (last update ID: {@event.LastUpdateId}). [thread: {Thread.CurrentThread.ManagedThreadId}{(@event.Token.IsCancellationRequested ? ", canceled" : string.Empty)}]");
return(null);
}
Logger?.LogDebug($"{nameof(OrderBookCache)} ({_symbol}): Updating order book (last update ID: {_orderBook.LastUpdateId} => {@event.LastUpdateId}). [thread: {Thread.CurrentThread.ManagedThreadId}{(@event.Token.IsCancellationRequested ? ", canceled" : string.Empty)}]");
_orderBook.Modify(@event.LastUpdateId, @event.Bids, @event.Asks);
_orderBookClone = _orderBook.Clone();
}
return(new OrderBookCacheEventArgs(_orderBookClone));
}
{ /// <summary>
/// Creates a new system protocol packet.
/// </summary>
public PacketBase createSystemPacket(ushort typeID, byte[] buffer, int offset, int size)
{ //Ready our packet base
PacketBase packet = null;
offset++;
size--;
//What are we dealing with?
switch (typeID)
{
case CS_Initial.TypeID:
packet = new CS_Initial(typeID, buffer, offset, size);
break;
case BoxPacket.TypeID:
packet = new BoxPacket(typeID, buffer, offset, size);
break;
case Disconnect.TypeID:
packet = new Disconnect(typeID, buffer, offset, size);
break;
case PingPacket.TypeID:
packet = new PingPacket(typeID, buffer, offset, size);
break;
case CS_State.TypeID:
packet = new CS_State(typeID, buffer, offset, size);
break;
case Reliable.TypeID:
packet = new Reliable(typeID, buffer, offset, size, 0);
break;
case Reliable.TypeID + 1:
packet = new Reliable(typeID, buffer, offset, size, 1);
break;
case Reliable.TypeID + 2:
packet = new Reliable(typeID, buffer, offset, size, 2);
break;
case Reliable.TypeID + 3:
packet = new Reliable(typeID, buffer, offset, size, 3);
break;
case OutOfSync.TypeID:
packet = new OutOfSync(typeID, buffer, offset, size, 0);
break;
case OutOfSync.TypeID + 1:
packet = new OutOfSync(typeID, buffer, offset, size, 1);
break;
case OutOfSync.TypeID + 2:
packet = new OutOfSync(typeID, buffer, offset, size, 2);
break;
case OutOfSync.TypeID + 3:
packet = new OutOfSync(typeID, buffer, offset, size, 3);
break;
case ReliableEcho.TypeID:
packet = new ReliableEcho(typeID, buffer, offset, size, 0);
break;
case ReliableEcho.TypeID + 1:
packet = new ReliableEcho(typeID, buffer, offset, size, 1);
break;
case ReliableEcho.TypeID + 2:
packet = new ReliableEcho(typeID, buffer, offset, size, 2);
break;
case ReliableEcho.TypeID + 3:
packet = new ReliableEcho(typeID, buffer, offset, size, 3);
break;
case ReliableBox.TypeID:
packet = new ReliableBox(typeID, buffer, offset, size, 0);
break;
case ReliableBox.TypeID + 1:
packet = new ReliableBox(typeID, buffer, offset, size, 1);
break;
case ReliableBox.TypeID + 2:
packet = new ReliableBox(typeID, buffer, offset, size, 2);
break;
case ReliableBox.TypeID + 3:
packet = new ReliableBox(typeID, buffer, offset, size, 3);
break;
case DataPacketRcv.TypeID:
packet = new DataPacketRcv(typeID, buffer, offset, size, 0);
break;
case DataPacketRcv.TypeID + 1:
packet = new DataPacketRcv(typeID, buffer, offset, size, 1);
break;
case DataPacketRcv.TypeID + 2:
packet = new DataPacketRcv(typeID, buffer, offset, size, 2);
break;
case DataPacketRcv.TypeID + 3:
packet = new DataPacketRcv(typeID, buffer, offset, size, 3);
break;
default:
//An undefined packet.
packet = new PacketDummy(typeID, buffer, offset, size);
break;
}
return(packet);
}
/// <summary>
/// Handles all out-of-sync notifications
/// </summary>
static public void Handle_OutOfSync(OutOfSync pkt, Client client)
{
//TODO: Resend packet?
//Log.write(TLog.Error, "** OUTOFSYNC: " + pkt.rNumber);
}
