private async Task ProcessOrdersAsync(
Order order,
IReliableDictionary <OrderQueueKey, OrderQueue> storage,
OrderQueueKey orderQueueKey,
OrderQueueKey oppositeOrderQueueKey)
{
using (var tx = _stateManager.CreateTransaction())
{
var orderQueue = await storage.GetOrAddAsync(
tx,
orderQueueKey,
new OrderQueue(order.CurrencyPair, order.Side));
var oppositeOrderQueue = await storage.GetOrAddAsync(
tx,
oppositeOrderQueueKey,
new OrderQueue(order.CurrencyPair, order.Side == Side.Buy ? Side.Sell : Side.Buy));
while (true)
{
var oppositeOrder = oppositeOrderQueue.Peek();
if (oppositeOrder == null)
{
break;
}
var matched = _ordersMatchingRule.IsMatched(order, oppositeOrder);
if (matched)
{
matched = _ordersMatchingRule.IsMatched(order, oppositeOrder);
if (matched)
{
ProcessOrders(order, orderQueue, oppositeOrder, oppositeOrderQueue);
}
else
{
// process further if some thread is here
continue;
}
}
if (order.IsClosed || !matched || oppositeOrderQueue.IsEmpty)
{
break;
}
}
await storage.AddOrUpdateAsync(tx, orderQueueKey, orderQueue, (key, old) => orderQueue);
await storage.AddOrUpdateAsync(tx, oppositeOrderQueueKey, oppositeOrderQueue, (key, old) => orderQueue);
await tx.CommitAsync();
}
}
private void CloseOrders(Order order)
{
OrderQueue oppositeQueue;
lock (_processOrdersSyncObject)
{
oppositeQueue = _orderQueueStorage.GetOrCreateOppositeQueue(order);
if (oppositeQueue.IsEmpty)
{
return;
}
}
while (true)
{
Order oppositeOrder;
lock (_processOrdersSyncObject)
{
oppositeOrder = oppositeQueue.Peek();
}
if (oppositeOrder == null)
{
break;
}
var matched = _ordersMatchingRule.IsMatched(order, oppositeOrder);
if (matched)
{
lock (_processOrdersSyncObject)
{
matched = _ordersMatchingRule.IsMatched(order, oppositeOrder);
if (matched)
{
ProcessOrders(order, oppositeOrder);
}
else
{
// process further if some thread is here
continue;
}
}
}
lock (_processOrdersSyncObject)
{
if (order.IsClosed || !matched || oppositeQueue.IsEmpty)
{
break;
}
}
}
}
