public async Task RestoreSwaps()
{
var positions = _ordersCache.Positions.GetAllPositions();
if (positions.Any())
{
var positionsIds = positions.Select(x => x.Id);
var swapTotalPerPosition = await _accountHistoryRepository.GetSwapTotalPerPosition(positionsIds);
if (swapTotalPerPosition.Any())
{
swapTotalPerPosition.ForEach(x =>
{
var position = positions.Single(p => p.Id == x.Key);
position.SetSwapTotal(x.Value);
});
try
{
await _blobRepository.WriteAsync(LykkeConstants.StateBlobContainer, OrderCacheManager.PositionsBlobName, positions);
}
catch (Exception ex)
{
await _log.WriteErrorAsync(nameof(OrdersCache), "Save positions", "", ex);
}
}
}
}
public async Task InvokeAll()
{
var migrationVersions = await _marginTradingBlobRepository.ReadAsync <Dictionary <string, int> >(
LykkeConstants.MigrationsBlobContainer, "versions") ?? new Dictionary <string, int>();
foreach (var migration in _migrations)
{
var migrationName = migration.GetType().Name;
try
{
if (!migrationVersions.TryGetValue(migrationName, out var version) ||
version < migration.Version)
{
await migration.Invoke();
migrationVersions.Remove(migrationName);
migrationVersions.Add(migrationName, migration.Version);
}
}
catch (Exception ex)
{
await _log.WriteFatalErrorAsync(nameof(MigrationService), migrationName, ex, DateTime.UtcNow);
}
}
await _marginTradingBlobRepository.WriteAsync(LykkeConstants.MigrationsBlobContainer, "versions", migrationVersions);
}
private async Task DumpOrdersToRepository()
{
try
{
var orders = _orderCache.GetAllOrders();
if (orders != null)
{
await _blobRepository.WriteAsync(LykkeConstants.StateBlobContainer, OrdersBlobName, orders);
}
}
catch (Exception ex)
{
await _log.WriteErrorAsync(nameof(OrdersCache), "Save orders", "", ex);
}
}
private async Task DumpToRepository()
{
try
{
await _blobRepository.WriteAsync(LykkeConstants.StateBlobContainer, BlobName, GetAllQuotes());
}
catch (Exception ex)
{
await _log.WriteErrorAsync(nameof(FxRateCacheService), "Save fx rates", "", ex);
}
}
private async Task DumpToRepository()
{
try
{
Dictionary <string, OrderBook> orderbookState;
using (_contextFactory.GetReadSyncContext($"{nameof(OrderBookSaveService)}.{nameof(DumpToRepository)}"))
orderbookState = _orderBookList.GetOrderBookState();
if (orderbookState != null)
{
await _blobRepository.WriteAsync(LykkeConstants.StateBlobContainer, BlobName, orderbookState);
}
}
catch (Exception ex)
{
await _log.WriteErrorAsync(nameof(OrderBookSaveService), "Save orderbook", "", ex);
}
}
public async Task SaveAsync(IReadOnlyCollection <RawMessage> items, string exchangeName)
{
await _blobRepository.WriteAsync(BlobContainer, exchangeName, items);
}
/// <inheritdoc />
public async Task <string> MakeTradingDataSnapshot(DateTime tradingDay, string correlationId, SnapshotStatus status = SnapshotStatus.Final)
{
if (!_scheduleSettingsCacheService.TryGetPlatformCurrentDisabledInterval(out var disabledInterval))
{
//TODO: remove later (if everything will work and we will never go to this branch)
_scheduleSettingsCacheService.MarketsCacheWarmUp();
if (!_scheduleSettingsCacheService.TryGetPlatformCurrentDisabledInterval(out disabledInterval))
{
throw new Exception(
$"Trading should be stopped for whole platform in order to make trading data snapshot. Current schedule: {_scheduleSettingsCacheService.GetPlatformTradingSchedule()?.ToJson()}");
}
}
if (disabledInterval.Start.AddDays(-1) > tradingDay.Date || disabledInterval.End < tradingDay.Date)
{
throw new Exception(
$"{nameof(tradingDay)}'s Date component must be from current disabled interval's Start -1d to End: [{disabledInterval.Start.AddDays(-1)}, {disabledInterval.End}].");
}
if (Lock.CurrentCount == 0)
{
throw new InvalidOperationException("Trading data snapshot creation is already in progress");
}
// We must be sure all messages have been processed by history brokers before starting current state validation.
// If one or more queues contain not delivered messages the snapshot can not be created.
_queueValidationService.ThrowExceptionIfQueuesNotEmpty(true);
// Before starting snapshot creation the current state should be validated.
var validationResult = await _snapshotValidationService.ValidateCurrentStateAsync();
if (!validationResult.IsValid)
{
var ex = new InvalidOperationException(
$"The trading data snapshot might be corrupted. The current state of orders and positions is incorrect. Check the dbo.BlobData table for more info: container {LykkeConstants.MtCoreSnapshotBlobContainer}, correlationId {correlationId}");
await _log.WriteFatalErrorAsync(nameof(SnapshotService),
nameof(MakeTradingDataSnapshot),
validationResult.ToJson(),
ex);
await _blobRepository.WriteAsync(LykkeConstants.MtCoreSnapshotBlobContainer, correlationId, validationResult);
}
else
{
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
"The current state of orders and positions is correct.");
}
await Lock.WaitAsync();
try
{
var orders = _orderReader.GetAllOrders();
var ordersJson = orders.Select(o => o.ConvertToSnapshotContract(_orderReader, status)).ToJson();
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
$"Preparing data... {orders.Length} orders prepared.");
var positions = _orderReader.GetPositions();
var positionsJson = positions.Select(p => p.ConvertToSnapshotContract(_orderReader, status)).ToJson();
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
$"Preparing data... {positions.Length} positions prepared.");
var accountStats = _accountsCacheService.GetAll();
var accountsJson = accountStats.Select(a => a.ConvertToSnapshotContract(status)).ToJson();
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
$"Preparing data... {accountStats.Count} accounts prepared.");
var bestFxPrices = _fxRateCacheService.GetAllQuotes();
var bestFxPricesData = bestFxPrices.ToDictionary(q => q.Key, q => q.Value.ConvertToContract()).ToJson();
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
$"Preparing data... {bestFxPrices.Count} best FX prices prepared.");
var bestPrices = _quoteCacheService.GetAllQuotes();
var bestPricesData = bestPrices.ToDictionary(q => q.Key, q => q.Value.ConvertToContract()).ToJson();
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
$"Preparing data... {bestPrices.Count} best trading prices prepared.");
var msg = $"TradingDay: {tradingDay:yyyy-MM-dd}, Orders: {orders.Length}, positions: {positions.Length}, accounts: {accountStats.Count}, best FX prices: {bestFxPrices.Count}, best trading prices: {bestPrices.Count}.";
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
$"Starting to write trading data snapshot. {msg}");
var snapshot = new TradingEngineSnapshot(
tradingDay,
correlationId,
_dateService.Now(),
ordersJson: ordersJson,
positionsJson: positionsJson,
accountsJson: accountsJson,
bestFxPricesJson: bestFxPricesData,
bestTradingPricesJson: bestPricesData,
status: status);
await _tradingEngineSnapshotsRepository.AddAsync(snapshot);
await _log.WriteInfoAsync(nameof(SnapshotService), nameof(MakeTradingDataSnapshot),
$"Trading data snapshot was written to the storage. {msg}");
return($"Trading data snapshot was written to the storage. {msg}");
}
finally
{
Lock.Release();
}
}