private async Task DoTimer(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct) { var balance = await _b2C2RestClient.BalanceAsync(ct); using (var context = CreateContext()) { var ts = DateTime.UtcNow; var items = new List <BalanceEntity>(); foreach (var assetBalance in balance) { var assetName = assetBalance.Key; foreach (var assetMapping in _assetMappings) { assetName = assetName.Replace(assetMapping.Key, assetMapping.Value); } var item = new BalanceEntity { Asset = assetName, Timestamp = ts, Balance = assetBalance.Value }; items.Add(item); } context.Balances.AddRange(items); await context.SaveChangesAsync(ct); } }
private async Task TimerHandlerAsync(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct) { _log.Info("Timer handler started..."); try { // Refresh CoinMarketCap data and rebuild constituents if needed bool rebuildNeeded; lock (_sync) { var lastRebuildWasYesterday = _lastRebuild.Date < DateTime.UtcNow.Date; var itIsTimeToRebuild = DateTime.UtcNow.TimeOfDay > Settings.RebuildTime; rebuildNeeded = _rebuildNeeded || lastRebuildWasYesterday && itIsTimeToRebuild; } if (rebuildNeeded) { await RefreshCoinMarketCapDataAsync(); await RebuildTopAssets(); await CheckForNewAssetsAsync(); } // Calculate new index await CalculateThenSaveAndPublishAsync(); } catch (Exception e) { _log.Warning("Somethings went wrong in timer handler.", e); } _log.Info("Timer handler finished."); }
private async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { var checkDate = await _lastMomentRepo.GetLastEventMomentAsync(_settings.AssetId) ?? _startedAt; // run heartbeat with delay if there are no cashout registered if (DateTime.UtcNow - checkDate > _settings.MaxCashoutInactivePeriod && !await _cashoutLockRepository.IsLockedAsync(_settings.AssetId)) { var opId = Guid.NewGuid(); _log.Info("Starting heartbeat cashout", context: new { opId, checkDate, _settings.AssetId }); _cqrsEngine.SendCommand(new StartHeartbeatCashoutCommand { Amount = _settings.Amount, AssetId = _settings.AssetId, OperationId = opId, ToAddress = _settings.ToAddress, ToAddressExtension = _settings.ToAddressExtension, MaxCashoutInactivePeriod = _settings.MaxCashoutInactivePeriod, ClientId = _settings.ClientId, FeeCashoutTargetClientId = _settings.FeeCashoutTargetClientId, ClientBalance = _settings.ClientBalance }, HeartbeatCashoutBoundedContext.Name, HeartbeatCashoutBoundedContext.Name); } }
private async Task MaintainTickerOnTriggered(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { // TODO: such an approach is Ok for the case of the single running service instance. But once we get // TODO: a necessity to run more instances, the code below will provoke a problem. await TruncateCacheAsync(); await ReloadCacheIfNeededAsync(); }
private async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { _log.Info("Starting checking and updating stakes"); var processExpiredReferralStakesTask = _referralStakesService.ProcessExpiredReferralStakes(); var processWarningsForReferralStakesTask = _referralStakesService.ProcessWarningsForReferralStakes(); await Task.WhenAll(processExpiredReferralStakesTask, processWarningsForReferralStakesTask); _log.Info("Finished checking and updating stakes"); }
private async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { var paymentsTask = _paymentsService.MarkPaymentsAsExpiredAsync(_paymentsExpirationPeriod); var requestsTask = _paymentsService.MarkRequestsAsExpiredAsync(); _log.Info("Starting checking and marking partners payments as expired"); await Task.WhenAll(paymentsTask, requestsTask); _log.Info("Finished checking and marking partners payments as expired"); }
private async Task DoTimer(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { foreach (var client in _cryptoIndexClientManager.GetAll()) { await LoadCryptoIndex(client.Key, client.Value); } await LoadMarketCupData(); await LoadPriceHistory(); }
public async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { try { await Execute(); } catch (Exception ex) { _log.Error(ex); } }
private async Task Handler(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { try { await DoTimer(); } catch (Exception ex) { Log.Error(ex, context: $"Metainfo: {Metainfo}"); } }
private async Task ReconnectIfNeeded(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct) { try { ReconnectIfNeeded(); } catch (Exception e) { _log.Info("Error during ReconnectIfNeeded.", exception: e); } }
private Task HandleTimerTriggered(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { if (DateTime.UtcNow > _currentBatchExpirationMoment) { _batchBlock.TriggerBatch(); ExtendBatchExpiration(); } return(Task.CompletedTask); }
private async Task DoTimer(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct) { if (!StartWork()) { return; } try { using (var context = CreateContext()) { var ledgerRequest = new LedgersRequest { Limit = 10 }; var data = await _b2C2RestClient.GetLedgerHistoryAsync(ledgerRequest, ct); var added = 0; do { added = 0; foreach (var log in data.Data) { foreach (var assetMapping in _assetMappings) { log.Currency = log.Currency.Replace(assetMapping.Key, assetMapping.Value); } var item = await context.Ledgers.FirstOrDefaultAsync( e => e.TransactionId == log.TransactionId, ct); if (item != null) { continue; } item = new LedgerEntity(log); context.Ledgers.Add(item); added++; } await context.SaveChangesAsync(ct); ledgerRequest.Cursor = data.Next; data = await _b2C2RestClient.GetLedgerHistoryAsync(ledgerRequest, ct); } while (added > 0); } } finally { StopWork(); } }
private Task CheckStreams(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { var streamsToRemove = _streamList .Where(x => x.CancelationToken.HasValue && x.CancelationToken.Value.IsCancellationRequested) .ToList(); foreach (var streamData in streamsToRemove) { RemoveStream(streamData); } return(Task.CompletedTask); }
private async Task ForceReconnect(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct) { _log.Info("Force reconnect by timer."); try { ForceReconnect(); } catch (Exception e) { _log.Info("Error during ForceReconnect.", exception: e); } }
public Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { try { Execute(); } catch (Exception ex) { _log.Error(ex); } return(Task.CompletedTask); }
private async Task DoTime(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { foreach (var service in _services.OrderBy(e => e.Order, OrderByDirection.Ascending)) { try { await service.CalculateMarket(); } catch (Exception ex) { _log.Error(ex, process: nameof(DoTime), context: service.Name); } } }
private async Task TimerTriggeredEventHandler( ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { try { _settingsValue = await DownloadSettingsAsync(); } catch (Exception e) { _log.Warning(e.Message, e); } }
private async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { var limitsReached = await _limitsService.GetAllLimitReachedAsync(); if (limitsReached.Count == 0) { return; } var clientIds = limitsReached.Select(x => x.ClientId).Distinct().ToArray(); var clients = (await _clientAccountClient.ClientAccountInformation.GetClientsByIdsAsync( new ClientIdsRequest { Ids = clientIds })).ToList(); var personalDatas = (await _personalDataService.GetAsync(clientIds)).ToList(); foreach (var limit in limitsReached) { var client = clients.FirstOrDefault(x => x.Id == limit.ClientId); var pd = personalDatas.FirstOrDefault(x => x.Id == limit.ClientId); if (client == null || pd == null) { _log.Warning("Client or personal data not found", context: limit.ClientId); continue; } var currentLimitSettingsTask = _limitsService.GetClientLimitSettingsAsync(limit.ClientId, client.Tier, pd.CountryFromPOA); var checkAmountTask = _limitsService.GetClientDepositAmountAsync(limit.ClientId); await Task.WhenAll(currentLimitSettingsTask, checkAmountTask); if (currentLimitSettingsTask.Result?.MaxLimit == null) { continue; } var checkAmount = checkAmountTask.Result; if (checkAmount < currentLimitSettingsTask.Result.MaxLimit.Value) { await _limitsService.RemoveLimitReachedAsync(limit.ClientId); _log.Info("Limit reached removed", context: limit.ClientId); } } }
private async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { var stopWatch = new Stopwatch(); stopWatch.Start(); await _operationOrchestratorService.ProcessHangedOperationsAsync(); stopWatch.Stop(); if (stopWatch.Elapsed > _idlePeriod) { _log.Warning("Processing of hanged operations takes more time than the idle period of the handler."); } }
private Task Ping(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { foreach (var streamData in _streamList) { var instance = streamData.LastSentData ?? Activator.CreateInstance <T>(); try { streamData.Stream.WriteAsync(instance) .ContinueWith(t => RemoveStream(streamData), TaskContinuationOptions.OnlyOnFaulted); } catch {} } return(Task.CompletedTask); }
public Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { try { _log.Info("Arbitrage Detector timer started..."); Execute(); } catch (Exception ex) { _log.Error(ex); } _log.Info("Arbitrage Detector timer finished."); return(Task.CompletedTask); }
private async Task DoTimer(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct) { if (!StartWork()) { return; } var offset = 0; var page = 100; try { using (var context = CreateContext()) { // Update trades from last time var data = await _b2C2RestClient.GetTradeHistoryAsync(offset, page, ct); var added = 0; do { added = 0; foreach (var log in data) { var item = await context.Trades.FirstOrDefaultAsync(e => e.TradeId == log.TradeId, ct); if (item != null) { continue; } item = new TradeEntity(log); context.Trades.Add(item); added++; } await context.SaveChangesAsync(ct); offset += data.Count; data = await _b2C2RestClient.GetTradeHistoryAsync(offset, page, ct); } while (added > 0); } } finally { StopWork(); } }
public virtual async Task Execute( ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { try { await _timePublisher.PublishAsync(new TimeEvent { TimeStamp = DateTime.UtcNow }); } catch (Exception exception) { _log.Warning("An error publishing event has occured", exception); } }
private Task Job(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { _lock.EnterReadLock(); List <StreamData <T> > streams; try { streams = _streamList .Where(x => !x.CancelationToken?.IsCancellationRequested ?? true) .ToList(); } finally { _lock.ExitReadLock(); } return(ProcesJobAsync(streams)); }
private async Task DoTimer(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken ct) { var balance = await _b2C2RestClient.BalanceAsync(ct); using (var context = CreateContext()) { var ts = DateTime.UtcNow; var items = balance.Select(e => new BalanceEntity { Asset = e.Key, Timestamp = ts, Balance = e.Value }).ToList(); context.Balances.AddRange(items); await context.SaveChangesAsync(ct); } }
private async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { var date = DateTime.UtcNow - _marketDataInterval; double to = date.ToUnixTime(); var assetPairIds = (await _marketProfileClient.ApiMarketProfileGetAsync(cancellationToken)) .Select(x => x.AssetPair) .ToList(); var tasks = new List <Task>(); foreach (var assetPairId in assetPairIds) { tasks.Add(_database.SortedSetRemoveRangeByScoreAsync(RedisService.GetMarketDataBaseVolumeKey(assetPairId), 0, to, Exclude.Stop, CommandFlags.FireAndForget)); tasks.Add(_database.SortedSetRemoveRangeByScoreAsync(RedisService.GetMarketDataQuoteVolumeKey(assetPairId), 0, to, Exclude.Stop, CommandFlags.FireAndForget)); tasks.Add(_database.SortedSetRemoveRangeByScoreAsync(RedisService.GetMarketDataPriceKey(assetPairId), 0, to, Exclude.Stop, CommandFlags.FireAndForget)); } await Task.WhenAll(tasks); }
private async Task ProcessBalancesAsync(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { var assets = (await _assetsService.GetAllAssetsAsync(false, cancellationToken)) .Where(a => a.BlockchainIntegrationLayerId == _blockchainType) .ToDictionary( a => a.BlockchainIntegrationLayerAssetId, a => a); var blockchainAssets = await _blockchainApiClient.GetAllAssetsAsync(_batchSize); var balanceProcessor = new BalanceProcessor( _blockchainType, _logFactory, _hotWalletsProvider, _blockchainApiClient, _cqrsEngine, _enrolledBalanceRepository, assets, blockchainAssets); await balanceProcessor.ProcessAsync(_batchSize); }
private async Task Execute(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationToken) { _log.Info(ComponentName, "Begining to process"); var collection = _mongoDatabase.GetCollection <TransactionMongoEntity>("txes"); var filterBuilder = Builders <TransactionMongoEntity> .Filter; var txesFilter = filterBuilder.Eq(x => x.WasProcessed, false) | filterBuilder.Exists(x => x.WasProcessed, false); var newTxes = collection.Find(txesFilter) .Limit(100) .ToList(); foreach (var tx in newTxes) { try { _log.Info(ComponentName, "Preparing to process", tx.TxId); if (tx.Vins.Count < 500 && tx.Vouts.Count < 500) { await _queueExt.PutRawMessageAsync(JsonConvert.SerializeObject(tx.ToTransitQueueMessage())); } var filter = Builders <TransactionMongoEntity> .Filter.Eq("txid", tx.TxId); var update = Builders <TransactionMongoEntity> .Update.Set("wasprocessed", true); await collection.UpdateOneAsync(filter, update); _log.Info(ComponentName, "Successfully processed", tx.TxId); } catch (Exception e) { _log.Error(ComponentName, e, null, tx.TxId); } } _log.Info(ComponentName, $"{newTxes.Count} tx-es successfully processed!"); }
private async Task Ping(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { var tasks = new List <Task>(); if (_streamList.Count == 0) { return; } for (var i = _streamList.Count - 1; i >= 0; i--) { var streamData = _streamList[i]; var instance = streamData.LastSentData ?? Activator.CreateInstance <T>(); var data = ProcessPingDataBeforeSend(instance, streamData); tasks.Add(WriteStreamAsync(streamData, data)); } if (tasks.Any()) { await Task.WhenAll(tasks); } }
private Task CheckStreams(ITimerTrigger timer, TimerTriggeredHandlerArgs args, CancellationToken cancellationtoken) { List <StreamData <T> > streamsToRemove; _lock.EnterReadLock(); try { streamsToRemove = _streamList .Where(x => x.CancelationToken.HasValue && x.CancelationToken.Value.IsCancellationRequested) .ToList(); } finally { _lock.ExitReadLock(); } foreach (var streamData in streamsToRemove) { RemoveStream(streamData); } return(Task.CompletedTask); }