public override async Task GetBalanceUpdates(Empty request, IServerStreamWriter <BalanceUpdate> responseStream, ServerCallContext context)
{
Console.WriteLine($"New balance stream connect. peer:{context.Peer}");
string walletId = context.GetHttpContext().User.GetWalletId();
var balances = await _balanceService.GetBalancesAsync(walletId);
var streamInfo = new StreamInfo <BalanceUpdate>
{
Stream = responseStream,
CancelationToken = context.CancellationToken,
Keys = new [] { context.GetHttpContext().User.GetWalletId() },
Peer = context.Peer
};
var initData = new BalanceUpdate();
initData.Balances.AddRange(_mapper.Map <List <Balance> >(balances));
//need to await returned task for stream to be opened
var task = await _balanceUpdateService.RegisterStreamAsync(streamInfo, new List <BalanceUpdate> {
initData
});
await task;
}
public async Task UpdateBalance()
{
AccountEntity testAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
Assert.NotNull(testAccount);
BalanceDTO accountBalance = testAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.NotNull(accountBalance);
//Execute balance update
double newBalance = accountBalance.Balance + 1.0;
string balanceUpdateId = Guid.NewGuid().ToString();
await this.Consumer.Client.UpdateBalanceAsync(balanceUpdateId, this.TestAccountId1, this.TestAsset1, newBalance);
BalanceUpdate message = (BalanceUpdate)await this.WaitForRabbitMQ <BalanceUpdate>(o => o.id == balanceUpdateId);
Assert.True(message.type == "BALANCE_UPDATE");
BalanceUpdate.ClientBalanceUpdate balance = message.balances.Where(m => m.id == this.TestAccountId1).FirstOrDefault();
Assert.True(balance != null);
Assert.True(balance.asset == this.TestAsset1);
Assert.True(balance.oldBalance == accountBalance.Balance);
Assert.True(balance.newBalance == newBalance);
Assert.True(balance.oldReserved == balance.newReserved);
AccountEntity checkTestAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
BalanceDTO checkAccountBalance = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.True(checkAccountBalance.Balance == newBalance);
//reverse balance update
string reverseBalanceUpdateId = Guid.NewGuid().ToString();
await this.Consumer.Client.UpdateBalanceAsync(reverseBalanceUpdateId, this.TestAccountId1, this.TestAsset1, accountBalance.Balance);
message = (BalanceUpdate)await this.WaitForRabbitMQ <BalanceUpdate>(o => o.id == reverseBalanceUpdateId);
Assert.True(message.type == "BALANCE_UPDATE");
balance = message.balances.Where(m => m.id == this.TestAccountId1).FirstOrDefault();
Assert.True(balance != null);
Assert.True(balance.asset == this.TestAsset1);
Assert.True(balance.oldBalance == newBalance);
Assert.True(balance.newBalance == accountBalance.Balance);
Assert.True(balance.oldReserved == balance.newReserved);
checkTestAccount = (AccountEntity)await this.AccountRepository.TryGetAsync(this.TestAccountId1);
checkAccountBalance = checkTestAccount.BalancesParsed.Where(b => b.Asset == this.TestAsset1).FirstOrDefault();
Assert.True(checkAccountBalance.Balance == accountBalance.Balance);
}
public void Start()
{
_pricesReader.SubscribeToUpdateEvents(prices =>
{
var tasks = prices.Select(price => _priceStraem.WriteToStreamAsync(_mapper.Map <PriceUpdate>(price), price.AssetPairId)).ToList();
Task.WhenAll(tasks).GetAwaiter().GetResult();
}, deleted => { });
_tickerReader.SubscribeToUpdateEvents(tickers =>
{
var tasks = tickers.Select(ticker => _tickerStream.WriteToStreamAsync(_mapper.Map <TickerUpdate>(ticker))).ToList();
Task.WhenAll(tasks).GetAwaiter().GetResult();
}, deleted => { });
_orderbookReader.SubscribeToUpdateEvents(orderbooks =>
{
var tasks = new List <Task>();
foreach (var orderbook in orderbooks)
{
var item = _mapper.Map <Orderbook>(orderbook);
item.Asks.AddRange(_mapper.Map <List <Orderbook.Types.PriceVolume> >(orderbook.Asks));
item.Bids.AddRange(_mapper.Map <List <Orderbook.Types.PriceVolume> >(orderbook.Bids));
tasks.Add(_orderbookStream.WriteToStreamAsync(item, orderbook.AssetPairId));
}
Task.WhenAll(tasks).GetAwaiter().GetResult();
}, deleted => { });
_balanceReader.SubscribeToUpdateEvents(balances =>
{
var balancesByWallet = balances.GroupBy(x => x.WalletId);
var tasks = new List <Task>();
foreach (var walletBalanes in balancesByWallet)
{
var balanceUpdate = new BalanceUpdate();
balanceUpdate.Balances.AddRange(_mapper.Map <List <Balance> >(walletBalanes.ToList()));
tasks.Add(_balanceStream.WriteToStreamAsync(balanceUpdate, walletBalanes.Key));
}
Task.WhenAll(tasks).GetAwaiter().GetResult();
}, deleted => { });
Console.WriteLine("Stream services started.");
}
private void BalanceUpdateHandler(BalanceUpdate message)
{
var result = message;
Console.WriteLine(JsonConvert.SerializeObject(result, Formatting.Indented));
}
public void Start()
{
_pricesReader.SubscribeToChanges(prices =>
{
foreach (var price in prices)
{
_priceStraem.WriteToStream(_mapper.Map <PriceUpdate>(price));
}
});
_tickerReader.SubscribeToChanges(tickers =>
{
foreach (var ticker in tickers)
{
_tickerStream.WriteToStream(_mapper.Map <TickerUpdate>(ticker));
}
});
_orderbookReader.SubscribeToChanges(orderbooks =>
{
foreach (var orderbook in orderbooks)
{
var item = _mapper.Map <Orderbook>(orderbook);
item.Asks.AddRange(_mapper.Map <List <Orderbook.Types.PriceVolume> >(orderbook.Asks));
item.Bids.AddRange(_mapper.Map <List <Orderbook.Types.PriceVolume> >(orderbook.Bids));
_orderbookStream.WriteToStream(item, orderbook.AssetPairId);
}
});
_balanceReader.SubscribeToChanges(balances =>
{
var balancesByWallet = balances.GroupBy(x => x.WalletId);
foreach (var walletBalanes in balancesByWallet)
{
var balanceUpdate = new BalanceUpdate();
balanceUpdate.Balances.AddRange(_mapper.Map <List <Balance> >(walletBalanes.ToList()));
_balanceStream.WriteToStream(balanceUpdate, walletBalanes.Key);
}
});
_orderReader.SubscribeToChanges(ordersEntities =>
{
var ordersByWallet = ordersEntities.GroupBy(x => x.WalletId);
foreach (var walletOrders in ordersByWallet)
{
var orderUpdate = new OrderUpdate();
orderUpdate.Orders.AddRange(_mapper.Map <List <Order> >(walletOrders.ToList()));
_orderStream.WriteToStream(orderUpdate, walletOrders.Key);
}
});
_tradeReader.SubscribeToChanges(tradeEntities =>
{
var tradesByWallet = tradeEntities.GroupBy(x => x.WalletId);
foreach (var walletTrades in tradesByWallet)
{
var tradeUpdate = new TradeUpdate();
tradeUpdate.Trades.AddRange(_mapper.Map <List <Trade> >(walletTrades.ToList()));
_tradeStream.WriteToStream(tradeUpdate, walletTrades.Key);
}
});
Console.WriteLine("Stream services started.");
}
