public async override Task Execute(IJobExecutionContext context) { var worker = (IBackgroundWorker)ServiceProvider.GetService(typeof(TWorker)); var workerContext = new PeriodicBackgroundWorkerContext(ServiceProvider); switch (worker) { case AsyncPeriodicBackgroundWorkerBase asyncWorker: { if (_doWorkAsyncMethod != null) { await(Task) _doWorkAsyncMethod.Invoke(asyncWorker, new object[] { workerContext }); } break; } case PeriodicBackgroundWorkerBase syncWorker: { if (_doWorkMethod != null) { _doWorkMethod.Invoke(syncWorker, new object[] { workerContext }); } break; } } }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { Logger.LogWarning("Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext"); await _configLoader.LoadFromDbIfChangedAsync(_lastSyncTime); _lastSyncTime = DateTime.UtcNow; }
protected async override Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { await workerContext .ServiceProvider .GetRequiredService <TokenCleanupService>() .CleanAsync(); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { await workerContext .ServiceProvider .GetRequiredService <TokenCleanupService>() .CleanAsync() .ConfigureAwait(false); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { Logger.LogInformation("Iniciando: Actualizacion de cotizacion de colones"); await Task.CompletedTask; Logger.LogInformation("Finalizado: Actualizacion de cotizacion de colones"); }
/// <summary> /// 执行定期任务. /// </summary> /// <param name="workerContext"></param> protected override void DoWork(PeriodicBackgroundWorkerContext workerContext) { // 最好使用 PeriodicBackgroundWorkerContext 解析依赖 而不是构造函数. // 因为 AsyncPeriodicBackgroundWorkerBase 使用 IServiceScope 在你的任务执行结束时会对其 disposed. // 使用属性注入也可以 var schoolRepository = workerContext.ServiceProvider.GetService <IProductRepository>(); _count++; }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { using (var scope = AuditingManager.BeginScope()) { await base.DoWorkAsync(workerContext); await scope.SaveAsync(); } }
protected async override Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { var store = workerContext.ServiceProvider.GetRequiredService <IBackgroundJobStore>(); var waitingJobs = await store.GetWaitingJobsAsync(WorkerOptions.MaxJobFetchCount); if (!waitingJobs.Any()) { return; } var jobExecuter = workerContext.ServiceProvider.GetRequiredService <IBackgroundJobExecuter>(); var clock = workerContext.ServiceProvider.GetRequiredService <IClock>(); var serializer = workerContext.ServiceProvider.GetRequiredService <IBackgroundJobSerializer>(); foreach (var jobInfo in waitingJobs) { jobInfo.TryCount++; jobInfo.LastTryTime = clock.Now; try { var jobConfiguration = JobOptions.GetJob(jobInfo.JobName); var jobArgs = serializer.Deserialize(jobInfo.JobArgs, jobConfiguration.ArgsType); var context = new JobExecutionContext(workerContext.ServiceProvider, jobConfiguration.JobType, jobArgs); try { await jobExecuter.ExecuteAsync(context); await store.DeleteAsync(jobInfo.Id); } catch (BackgroundJobExecutionException) { var nextTryTime = CalculateNextTryTime(jobInfo, clock); if (nextTryTime.HasValue) { jobInfo.NextTryTime = nextTryTime.Value; } else { jobInfo.IsAbandoned = true; } await TryUpdateAsync(store, jobInfo); } } catch (Exception ex) { Logger.LogException(ex); jobInfo.IsAbandoned = true; await TryUpdateAsync(store, jobInfo); } } }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { var hostRunningToken = workerContext.ServiceProvider .GetRequiredService <HostRunningToken>(); var licenseClient = workerContext.ServiceProvider .GetRequiredService <LicenseClient>(); var isOnline = await licenseClient.IsOnline(); if (!isOnline) { hostRunningToken.Cancel(); } }
protected async override Task DoWorkAsync( PeriodicBackgroundWorkerContext workerContext) { Logger.LogInformation("Starting: Setting status of inactive FileChecker..."); var _repository = workerContext .ServiceProvider .GetRequiredService <IFileRepository>(); var compareTime = DateTime.Now.AddDays(-7); var query = (await _repository.GetQueryableAsync()).Where(x => x.FileContainerName == FileContainerNameConsts.Temp && x.CreationTime < compareTime); Logger.LogInformation("Completed: Setting status of inactive FileChecker..."); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { // 获取货币汇率并执行更新 var exchangeRate = await _exchangeRateApiService.QueryAsync(); var currencies = await _reository.GetAllListAsync(); foreach (var currency in currencies) { if (exchangeRate.ContainsKey(currency.CurrencyCode)) { currency.UpdateExchangeRate(exchangeRate[currency.CurrencyCode]); } } }
/// <summary> /// 异步执行任务 /// </summary> /// <param name="workerContext"></param> /// <returns></returns> protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { var tables = new[] { Initializer.GetPublishedTableName(), Initializer.GetReceivedTableName() }; foreach (var table in tables) { Logger.LogDebug($"Collecting expired data from table: {table}"); var time = DateTime.Now; await Storage.DeleteExpiresAsync(table, time, Options.CleanUpExpiresMessageBatch); } }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { try { var store = workerContext.ServiceProvider.GetRequiredService <INotificationStore>(); Logger.LogDebug("Before cleanup exprition jobs..."); await store.DeleteNotificationAsync(Options.CleanupBatchSize); Logger.LogDebug("Exprition jobs cleanup job was successful..."); } catch (Exception ex) { Logger.LogWarning("Exprition jobs cleanup job was failed..."); Logger.LogWarning("Error:{0}", ex.Message); } }
public override async Task DoWorkAsync() { var workerContext = new PeriodicBackgroundWorkerContext(ServiceProvider); var worker = ServiceProvider.GetRequiredService <TWorker>(); switch (worker) { case AsyncPeriodicBackgroundWorkerBase asyncPeriodicBackgroundWorker: await(Task) _doWorkAsyncMethod.Invoke(asyncPeriodicBackgroundWorker, new object[] { workerContext }); break; case PeriodicBackgroundWorkerBase periodicBackgroundWorker: _doWorkMethod.Invoke(periodicBackgroundWorker, new object[] { workerContext }); break; } }
protected async override Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { await using (var handle = await DistributedLock.TryAcquireAsync(nameof(TokenCleanupBackgroundWorker))) { Logger.LogInformation($"Lock is acquired for {nameof(TokenCleanupBackgroundWorker)}"); if (handle != null) { await workerContext .ServiceProvider .GetRequiredService <TokenCleanupService>() .CleanAsync(); Logger.LogInformation($"Lock is released for {nameof(TokenCleanupBackgroundWorker)}"); return; } Logger.LogInformation($"Handle is null because of the locking for : {nameof(TokenCleanupBackgroundWorker)}"); } }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { Logger.LogDebug("Starting: {0}", GetType()); IClock clock = workerContext.ServiceProvider.GetRequiredService <IClock>(); if (clock.Now.Hour == 0 && clock.Now.Minute == 3) { Logger.LogInformation("Starting: {0}", GetType()); IFileCrawlerRepository fileCrawlerRepository = workerContext.ServiceProvider.GetRequiredService <IFileCrawlerRepository>(); List <FileCrawler> fileCrawlerList = await fileCrawlerRepository.GetListAsync(); FileCrawlerRecordDomainService recordDomainService = workerContext.ServiceProvider.GetRequiredService <FileCrawlerRecordDomainService>(); foreach (FileCrawler fileCrawler in fileCrawlerList) { await recordDomainService.InsertAsync(fileCrawler, clock.Now.Date); } Logger.LogInformation("Completed: {0}", GetType()); } Logger.LogDebug("Completed: {0}", GetType()); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { await DoReconnectionJobAsync(); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { await ProcessDownloadJobAsync(); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { Debug.WriteLine($"Doing some work here"); await Task.Delay(5000); }
protected abstract Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext);
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { var stopwatch = new Stopwatch(); stopwatch.Start(); Logger.LogInformation("Starting at {0}: Monitoring the website’s health...", stopwatch.Elapsed.Milliseconds); var guidGenerator = workerContext.ServiceProvider.GetRequiredService <IGuidGenerator>(); var unitOfWorkManager = workerContext.ServiceProvider.GetRequiredService <UnitOfWorkManager>(); var monitorRepository = workerContext.ServiceProvider.GetRequiredService <IMonitorRepository>(); var clientFactory = workerContext.ServiceProvider.GetRequiredService <IHttpClientFactory>(); var monitors = await monitorRepository.GetListByStepFilterAsync(MonitorStepTypes.Request); monitors = monitors .Where(x => x.LastModificationTime == null ? x.CreationTime.ToUniversalTime().AddSeconds(x.MonitorStep.Interval) < DateTime.UtcNow : x.LastModificationTime?.ToUniversalTime().AddMinutes(x.MonitorStep.Interval) < DateTime.UtcNow) .ToList(); foreach (var monitor in monitors) { if (!monitor.MonitorStep.Url.IsNullOrEmpty()) { var logInterval = monitor.MonitorStep.Interval; var monitorStepLog = new MonitorStepLog( guidGenerator.Create(), monitor.Id, DateTime.UtcNow, MonitorStepStatusTypes.Processing, logInterval); monitor.AddMonitorStepLog(monitorStepLog); monitorStepLog.Status = MonitorStepStatusTypes.Processing; await monitorRepository.UpdateAsync(monitor); await unitOfWorkManager.Current.SaveChangesAsync(); try { var client = clientFactory.CreateClient(); client.Timeout = TimeSpan.FromSeconds(15); var response = await client.GetAsync(monitor.MonitorStep.Url); monitorStepLog.Status = MonitorStepStatusTypes.Pending; if (response.IsSuccessStatusCode) { monitorStepLog.Status = MonitorStepStatusTypes.Success; } else { monitorStepLog.Status = MonitorStepStatusTypes.Fail; } } catch (HttpRequestException rex) { monitorStepLog.SetLog(rex.Message); monitorStepLog.Status = MonitorStepStatusTypes.Fail; } catch (Exception ex) { monitorStepLog.SetLog(ex.Message); monitorStepLog.Status = MonitorStepStatusTypes.Error; } finally { monitorStepLog.EndDate = DateTime.UtcNow; } switch (monitorStepLog.Status) { case MonitorStepStatusTypes.Success: monitor.MonitorStep.Status = MonitorStepStatusTypes.Success; monitor.MonitorStatus = MonitorStatusTypes.Up; break; case MonitorStepStatusTypes.Error: monitor.MonitorStep.Status = MonitorStepStatusTypes.Error; monitor.MonitorStatus = MonitorStatusTypes.Warning; break; default: monitor.MonitorStep.Status = MonitorStepStatusTypes.Fail; monitor.MonitorStatus = MonitorStatusTypes.Down; break; } } monitor.LastModificationTime = DateTime.UtcNow; await monitorRepository.UpdateAsync(monitor); await unitOfWorkManager.Current.SaveChangesAsync(); await PublishUserNotifyEvent(monitor); } stopwatch.Stop(); var stopwatchElapsed = stopwatch.Elapsed; Logger.LogInformation("Completed at {0} ms: Monitoring the website’s health...", stopwatchElapsed.TotalMilliseconds); }
protected override Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { _Count++; return(Task.CompletedTask); }
protected override Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { Console.WriteLine("from async background worker 3"); return(Task.CompletedTask); }
/* * private async Task InitAsync(PeriodicBackgroundWorkerContext workerContext) * { * var pipelineHistoryRepository = workerContext.ServiceProvider * .GetRequiredService<IRepository<PipelineHistory, int>>(); * * _pipelineHistoryIdList = await pipelineHistoryRepository.Where(p => !p.()).Select(p => p.Id).ToListAsync(); * } */ private async Task <PipelineHistory> UpdatePipelineHistoryAsync(int pipelineHistoryId, PeriodicBackgroundWorkerContext workerContext) { var pipelineHistoryRepository = workerContext.ServiceProvider .GetRequiredService <IRepository <PipelineHistory, int> >(); var pipelineHistoryService = workerContext.ServiceProvider .GetRequiredService <PipelineHistoryService>(); var pipelineRunStatus = await pipelineHistoryService.GetStatusAsync(pipelineHistoryId.ToString()); var pipelineHistory = await pipelineHistoryRepository.GetAsync(pipelineHistoryId); var nodeDic = Digram.CreateInstance(pipelineHistory.Diagram).NodeList.ToDictionary(t => t.Id); pipelineRunStatus.TaskRunStatusList.ForEach(t => { t.TaskAnnoName = nodeDic[t.ShapeId].AnnoName; t.ConfigUrl = nodeDic[t.ShapeId].ConfigUrl; t.ResultUrl = nodeDic[t.ShapeId].ResultUrl; nodeDic[t.ShapeId].Destination.ForEach(id => t.NextShapes.Add(id)); if (t.Log == null) { return; } if (t.Log.StartTime == null) { t.Log.ExecTime = null; } else if (t.Log.CompletionTime == null) { t.Log.ExecTime = DateTime.Now - t.Log.StartTime; } else { t.Log.ExecTime = t.Log.CompletionTime - t.Log.StartTime; } }); /*pipelineHistory * .SetStatus( * pipelineRunStatus.Status, * pipelineRunStatus.StartTime, * pipelineRunStatus.CompletionTime, * pipelineRunStatus.Percent, * pipelineRunStatus.Logs)*/ pipelineHistory .SetStatus(pipelineRunStatus.Status) .SetStartTime(pipelineRunStatus.StartTime) .SetCompletionTime(pipelineRunStatus.CompletionTime) .SetPercent(pipelineRunStatus.Percent) .SetLogs(pipelineRunStatus.Logs) .SetMessage(pipelineRunStatus.Message); await pipelineHistoryRepository.UpdateAsync(pipelineHistory); return(pipelineHistory); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { //retrieve data from api and save to database await _theMovieDbApiIntegrationService.RetrieveTopRatedMovieResult(); }
protected override async Task DoWorkAsync( PeriodicBackgroundWorkerContext workerContext) { /* * if (!_isInited) * { * await InitAsync(workerContext); * _isInited = true; * } */ int pipelineHistoryId = 0; while (PipelineHistoryCreatedQueue.TryDequeue(out pipelineHistoryId)) { _pipelineHistoryTobeCheckSet.Add(pipelineHistoryId); } var pipelineHistoryService = workerContext.ServiceProvider .GetRequiredService <PipelineHistoryService>(); var pipelineHistoryTobeUncheckSet = new HashSet <int>(); foreach (var pipelineHistoryTobeCheck in _pipelineHistoryTobeCheckSet) { try{ var pipelineHistory = await UpdatePipelineHistoryAsync(pipelineHistoryTobeCheck, workerContext); if (pipelineHistory.IsFinish()) { pipelineHistoryService.DeletePipelinerun(pipelineHistory.Id); pipelineHistoryTobeUncheckSet.Add(pipelineHistoryTobeCheck); } } catch (Exception e) { Console.WriteLine(e); } } _pipelineHistoryTobeCheckSet.RemoveWhere(p => pipelineHistoryTobeUncheckSet.Contains(p)); while (PipelineHistoryTobeDeleteQueue.TryDequeue(out pipelineHistoryId)) { if (_pipelineHistoryTobeCheckSet.Contains(pipelineHistoryId)) { pipelineHistoryService.DeletePipelinerun(pipelineHistoryId); _pipelineHistoryTobeCheckSet.Remove(pipelineHistoryId); } pipelineHistoryService.DeletePVC(pipelineHistoryId); } /* * for (int i = _pipelineHistoryIdList.Count - 1; i >= 0; i--) * { * try{ * var pipelineHistory = await UpdatePipelineHistoryAsync(_pipelineHistoryIdList[i], workerContext); * if (pipelineHistory.IsFinish()) _pipelineHistoryIdList.RemoveAt(i); * } * catch (Exception e) { * Console.WriteLine(e); * } * } */ }
protected override void DoWork(PeriodicBackgroundWorkerContext workerContext) { Console.WriteLine("periodic worker 2 is started"); }
protected override async Task DoWorkAsync(PeriodicBackgroundWorkerContext workerContext) { await ProcessPeerDiscoveryJobAsync(); }
/// <summary> /// Periodic works should be done by implementing this method. /// </summary> protected abstract void DoWork(PeriodicBackgroundWorkerContext workerContext);