private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.UtcNow; var tasksThatShouldRun = _scheduledTasks.Where(t => t.ShouldRun(referenceTime)).ToList(); foreach (var taskThatShouldRun in tasksThatShouldRun) { taskThatShouldRun.Increment(); await taskFactory.StartNew( async() => { try { await taskThatShouldRun.Task.ExecuteAsync(cancellationToken); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } }
public Func <Task> RunContainers(IList <WorkflowContainer> containers, CancellationToken cancellationToken) { return(async() => { try { using (var scope = _serviceScopeFactory.CreateScope()) { // Run all the same workflow type in a sequential order foreach (var container in containers) { await RunContainer(scope.ServiceProvider, container, cancellationToken); } } } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }); }
private void ExecuteOne(CancellationToken cancellationToken) { try { // Run only one specific workflow using (var scope = _serviceScopeFactory.CreateScope()) { var workflowService = scope.ServiceProvider.GetRequiredService <IWorkflowService>(); var db = scope.ServiceProvider.GetRequiredService <TrustDBContext>(); var workflowContainer = db.Workflows.SingleOrDefaultAsync(m => m.DatabaseID == ContainerId).GetAwaiter().GetResult(); RunContainer(scope.ServiceProvider, workflowContainer, cancellationToken).GetAwaiter().GetResult(); } } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } finally { ContainerId = 0; } }
private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); foreach (var taskThatShouldRun in _scheduledTasks) { await taskFactory.StartNew( async() => { try { await taskThatShouldRun.ExecuteAsync(cancellationToken); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } }
private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.UtcNow + TimeSpan.Parse("07:00:00"); var tasksThatShouldRun = _scheduledTasks.Where(t => t.ShouldRun(referenceTime)).ToList(); foreach (var taskThatShouldRun in tasksThatShouldRun) { taskThatShouldRun.Increment(); await taskFactory.StartNew( async() => { try { await taskThatShouldRun.Task.ExecuteAsync(cancellationToken); } catch (Exception ex) { string msg = ex.Message; cls.WriteFile("Error.txt", msg); //Write error in textfile var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } }
protected override async Task ExecuteAsync(CancellationToken stoppingToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); _logger.LogInformation("BackgroundTaskService is starting."); while (!stoppingToken.IsCancellationRequested) { var job = await _taskManager.Dequeue(stoppingToken); await taskFactory.StartNew( async() => { try { await ExecuteOnce(job); } catch (Exception ex) { _logger.LogError(ex, "Exception found when execute job {0}.{1}", job.MethodInfo.DeclaringType, job.MethodInfo.Name); var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, stoppingToken); } _logger.LogInformation("BackgroundTaskService is stopping"); }
private async Task ExecuteEndlessAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var tasksAvailable = _scheduledTasks.Where(t => t.IsAvailable(DateTime.UtcNow)).ToList(); foreach (var targetTask in tasksAvailable) { await taskFactory.StartNew( async() => { try { await targetTask.RunAsync(cancellationToken); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs(ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } }
internal static void PublishUnobservedTaskException(Exception ex) { if (ex != null) { if (!PropagateOperationCanceledException && ex is OperationCanceledException) { return; } if (UnobservedTaskException != null) { #if !UniRxLibrary if (Thread.CurrentThread.ManagedThreadId == PlayerLoopHelper.MainThreadId) { // allows inlining call. UnobservedTaskException.Invoke(ex); } else { // Post to MainThread. PlayerLoopHelper.UnitySynchronizationContext.Post(handleExceptionInvoke, ex); } #else UnobservedTaskException.Invoke(ex); #endif } else { #if !UniRxLibrary string msg = null; if (UnobservedExceptionWriteLogType != UnityEngine.LogType.Exception) { msg = "UnobservedTaskException:" + ex.ToString(); } switch (UnobservedExceptionWriteLogType) { case UnityEngine.LogType.Error: UnityEngine.Debug.LogError(msg); break; case UnityEngine.LogType.Assert: UnityEngine.Debug.LogAssertion(msg); break; case UnityEngine.LogType.Warning: UnityEngine.Debug.LogWarning(msg); break; case UnityEngine.LogType.Log: UnityEngine.Debug.Log(msg); break; case UnityEngine.LogType.Exception: UnityEngine.Debug.LogException(ex); break; default: break; } #else Console.WriteLine("UnobservedTaskException:" + ex.ToString()); #endif } } }
private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.UtcNow; var tasksThatShouldRun = _scheduledTasks.Where(t => t.ShouldRun(referenceTime)).ToList(); foreach (var taskThatShouldRun in tasksThatShouldRun) { taskThatShouldRun.Increment(); await taskFactory.StartNew( async() => { try { using (var scope = _serviceScopeFactory.CreateScope()) { var t = taskThatShouldRun.Task.GetType(); var method = t.GetMethod("Invoke", BindingFlags.Instance | BindingFlags.Public); var arguments = method.GetParameters() .Select(a => a.ParameterType == typeof(CancellationToken) ? cancellationToken : scope.ServiceProvider.GetService(a.ParameterType)) .ToArray(); //invoke. if (typeof(Task).Equals(method.ReturnType)) { await(Task) method.Invoke(taskThatShouldRun.Task, arguments); } else { method.Invoke(taskThatShouldRun.Task, arguments); } } } catch (Exception ex) { _logger.LogError(ex, "BackgroundTask Error"); var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } }
private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.UtcNow; foreach (var flushTask in _scheduledReporters) { if (!flushTask.ShouldRun(referenceTime)) { Logger.Trace($"Skipping {flushTask.Reporter.GetType().FullName}, next run in {flushTask.NextRunTime.Subtract(referenceTime).Milliseconds} ms"); continue; } flushTask.Increment(); await taskFactory.StartNew( async() => { try { Logger.Trace($"Executing reporter {flushTask.Reporter.GetType().FullName} FlushAsync"); var result = await flushTask.Reporter.FlushAsync( _metrics.Snapshot.Get(flushTask.Reporter.Filter), cancellationToken); if (result) { _metrics.Measure.Counter.Increment(_successCounter, flushTask.Reporter.GetType().FullName); Logger.Trace($"Reporter {flushTask.Reporter.GetType().FullName} FlushAsync executed successfully"); } else { _metrics.Measure.Counter.Increment(_failedCounter, flushTask.Reporter.GetType().FullName); Logger.Warn($"Reporter {flushTask.Reporter.GetType().FullName} FlushAsync failed"); } } catch (Exception ex) { _metrics.Measure.Counter.Increment(_failedCounter, flushTask.Reporter.GetType().FullName); var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); Logger.Error($"Reporter {flushTask.Reporter.GetType().FullName} FlushAsync failed", ex); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } }
internal static void PublishUnobservedTaskException(Exception ex) { if (ex != null) { if (!PropagateOperationCanceledException && ex is OperationCanceledException) { return; } if (UnobservedTaskException != null) { if (Thread.CurrentThread.ManagedThreadId == PlayerLoopHelper.MainThreadId) { // allows inlining call. UnobservedTaskException.Invoke(ex); } else { // Post to MainThread. PlayerLoopHelper.UnitySynchronizationContext.Post(handleExceptionInvoke, ex); } } else { string msg = null; if (UnobservedExceptionWriteLogType != LogType.Exception) { msg = "UnobservedTaskException:" + ex; } switch (UnobservedExceptionWriteLogType) { case LogType.Error: Debug.LogError(msg); break; case LogType.Assert: Debug.LogAssertion(msg); break; case LogType.Warning: Debug.LogWarning(msg); break; case LogType.Log: Debug.Log(msg); break; case LogType.Exception: Debug.LogException(ex); break; } } } }
protected override async Task ExecuteAsync(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.Now; var tasksThatShouldRun = _scheduledTasks.Where(t => t.ShouldRun(referenceTime)).ToList(); foreach (var taskThatShouldRun in tasksThatShouldRun) { var currentTask = taskThatShouldRun.CurrenTask; if (currentTask != null && !TaskStatuses.FinishedStatuses.Contains(currentTask.Status)) { continue; } if (currentTask?.IsCompleted == true) { currentTask.Dispose(); } taskThatShouldRun.SetNextRunTime(); taskThatShouldRun.CurrenTask = taskFactory .StartNew( async() => { try { await taskThatShouldRun.RunTask(cancellationToken); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken) .Unwrap(); } await Task.Delay(TimeSpan.FromSeconds(RecurrenceInSecs), cancellationToken); } }
private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.UtcNow; foreach (var reportTask in _scheduledReporters) { if (!reportTask.ShouldRun(referenceTime)) { Logger.Trace($"Skipping {reportTask.Reporter.GetType().FullName}, next run in {reportTask.NextRunTime.Subtract(referenceTime).Milliseconds} ms"); continue; } reportTask.Increment(); await taskFactory.StartNew( async() => { try { Logger.Trace($"Executing reporter {reportTask.Reporter.GetType().FullName}"); var healthStatus = await _healthRoot.HealthCheckRunner.ReadAsync(cancellationToken); await reportTask.Reporter.ReportAsync(_healthRoot.Options, healthStatus, cancellationToken); Logger.Trace($"Reporter {reportTask.Reporter.GetType().FullName} executed successfully"); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); Logger.Error($"Reporter {reportTask.Reporter.GetType().FullName} failed", ex); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } }
private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.UtcNow; #if DEBUG Debug.WriteLine("ExecuteOnceAsync "); #endif var tasksThatShouldRun = _scheduledTasks.Where(t => t.ShouldRun(referenceTime) && !t.Task.IsRunning).ToList(); foreach (var taskThatShouldRun in tasksThatShouldRun) { taskThatShouldRun.Increment(); #if DEBUG Debug.WriteLine("Start " + taskThatShouldRun.Task.ToString()); #endif await taskFactory.StartNew( async() => { try { await taskThatShouldRun.Task.ExecuteAsync(cancellationToken); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); #if DEBUG Debug.WriteLine("executed " + taskThatShouldRun.Task.ToString()); #endif } }
private async Task ExecuteTask(ScheduledTaskWrapper taskWrapper, ScheduleMode mode, CancellationToken cancellationToken, params object[] args) { try { if (taskWrapper.Task is ScheduledTask) { var task = taskWrapper.Task as ScheduledTask; var count = task.Pipeline.Count(); var msg = $"Starting task {task.GetType().Name} [{mode.ToString()}]"; if (count > 1) { msg = $"{msg} (pipeline of {task.Pipeline.Count()} items)"; //log.LogInformation($"Starting task {task.GetType().Name} (pipeline of {task.Pipeline.Count()} items)"); } log.Information(msg); } var sw = new Stopwatch(); using (var sm = new SemaphoreSlim(1, 1)) { await sm.WaitAsync(); taskWrapper.IsRunning = true; //taskWrapper.Task.SetMode() sw.Start(); await taskWrapper.Task.ExecuteAsync(mode, cancellationToken, args); sw.Stop(); taskWrapper.IsRunning = false; log.Information($"Task {taskWrapper.Task.GetType().Name} completed in {sw.Elapsed}, will run next at {taskWrapper.NextRunTime.ToLocalTime().ToDefaultWithTime()}"); } } catch (Exception ex) { var ex_args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, ex_args); if (!ex_args.Observed) { throw; } } }
// Derived classes should override this and execute a long running method until // cancellation is requested protected async Task ExecuteAsync(CancellationToken cancellationToken) { while (!cancellationToken.IsCancellationRequested) { try { await _taskToExecute.ExecuteAsync(cancellationToken); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } await Task.Delay(TimeSpan.FromMinutes(1), cancellationToken); } }
private async Task ExecuteOnceAsync(CancellationToken stoppingToken) { var referenceTime = DateTimeOffset.UtcNow; var scheduledTasks = _registrations.Jobs.Values; var tasksThatShouldRun = scheduledTasks.Where(t => t.ShouldRun(referenceTime)).ToList(); foreach (var taskThatShouldRun in tasksThatShouldRun) { taskThatShouldRun.Increment(); #pragma warning disable CA2008 // Do not create tasks without passing a TaskScheduler await _taskFactory.StartNew( async() => { try { await taskThatShouldRun.ScheduledJob.ExecuteAsync(stoppingToken); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, stoppingToken); #pragma warning restore CA2008 // Do not create tasks without passing a TaskScheduler } }
//////////////////////////////////////////////////////////// // // Internal methods // // This is called by the TaskExceptionHolder finalizer. internal static void PublishUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs ueea) { UnobservedTaskException?.Invoke(sender, ueea); }
private void OnUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e) => UnobservedTaskException?.Invoke(this, e);
private async Task ExecuteOnceAsync(IScope scope, CancellationToken cancellationToken) { var taskFactory = new TaskFactory(TaskScheduler.Current); var referenceTime = DateTime.UtcNow; var tasksThatShouldRun = _scheduledTasks.Where(t => t.ShouldRun(referenceTime)); // each task will have its InvokeAsync method level dependencies resolved // and the method will be invoked. // The method invocation delegate is cached and called by `DynamicInvoke`, allowing // the method to be called without using reflection. // // Each task is kicked off without blocking other tasks that should run at the same time. object now = referenceTime; // cast to object to avoid boxing multiple times when calling the logger foreach (var taskThatShouldRun in tasksThatShouldRun) { if (!_argumentCache.TryGetValue(taskThatShouldRun, out var methodArgumentPair)) { methodArgumentPair = ExtractInvocationInfo(taskThatShouldRun); _argumentCache[taskThatShouldRun] = methodArgumentPair; } var arguments = methodArgumentPair.ArgumentTypes .Select(t => t == typeof(CancellationToken) ? cancellationToken : scope.GetInstance(t)) .ToArray(); taskThatShouldRun.Increment(); Stopwatch sw = null; #pragma warning disable AsyncFixer05 // Downcasting from a nested task to an outer task. await taskFactory.StartNew( async() => { try { _logger.InfoFormat("Beginning Invoke of task {0} at {1} UTC", taskThatShouldRun.Task, now); sw = Stopwatch.StartNew(); await(Task) methodArgumentPair.InvokeDelegate.DynamicInvoke(arguments); } catch (Exception ex) { _logger.WarnFormat("Task {0} threw error {1}", taskThatShouldRun, ex.Message); var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { _logger.Error( "Exception was not marked as handled in the UnobservedTaskException event. Rethrowing."); throw; } } finally { sw?.Stop(); _logger.InfoFormat("Task {0} completed in {1}", taskThatShouldRun.Task, sw?.Elapsed); } }, cancellationToken); #pragma warning restore AsyncFixer05 // Downcasting from a nested task to an outer task. } }
private async Task ExecuteOnceAsync(CancellationToken cancellationToken) { using (var scope = _provider.CreateScope()) { var db = scope.ServiceProvider.GetRequiredService <CrmsContext>(); var timer = scope.ServiceProvider.GetService <ITimerService>(); var taskFactory = new TaskFactory(TaskScheduler.Current); var task = taskFactory.StartNew(() => timer?.Scheduled(), cancellationToken); foreach (var eventAttribute in Events) { var type = db.Model.FindEntityType(eventAttribute.Table.FullName); var dbset = (IQueryable <object>) db .GetType() .GetRuntimeProperties() .FirstOrDefault(o => o.PropertyType.IsGenericType && o.PropertyType.GetGenericTypeDefinition() == typeof(DbSet <>) && o.PropertyType.GenericTypeArguments.Contains(type.ClrType)) ?.GetValue(db) ?? throw new Exception(); var realParams = dbset .Where(e => TimeInInterval((DateTime)type.GetProperties() .Single(p => p.Name == eventAttribute.TimeColumn && p.ClrType == typeof(DateTime)) .PropertyInfo.GetValue(e))) .Where(e => eventAttribute.WhereColumns .Select(col => col.StartsWith("!") ? Tuple.Create(col.Substring(1), true) : Tuple.Create(col, false)) .Select(ci => ci.Item2 ^ Convert.ToBoolean(type.GetProperties().Single(ppt => ppt.Name == ci.Item1).PropertyInfo.GetValue(e))).All(b => b)) .Select(e => eventAttribute.ParamColumns.Select(col => e.GetType().GetProperty(col).GetValue(e)) .ToArray()).ToList(); foreach (var parameters in realParams) { var instance = scope.ServiceProvider.GetRequiredService(eventAttribute.Callback.DeclaringType); await taskFactory.StartNew( () => { try { eventAttribute.Callback.Invoke(instance, parameters); } catch (Exception ex) { var args = new UnobservedTaskExceptionEventArgs( ex as AggregateException ?? new AggregateException(ex)); UnobservedTaskException?.Invoke(this, args); if (!args.Observed) { throw; } } }, cancellationToken); } } await task; } }