public async Task <JobResult> ProcessAsync(IQueueEntry <T> queueEntry, CancellationToken cancellationToken) { if (queueEntry == null) { return(JobResult.Success); } if (cancellationToken.IsCancellationRequested) { _logger.Info(() => $"Job was cancelled. Abandoning {_queueEntryName} queue item: {queueEntry.Id}"); await queueEntry.AbandonAsync().AnyContext(); return(JobResult.CancelledWithMessage($"Abandoning {_queueEntryName} queue item: {queueEntry.Id}")); } var lockValue = await GetQueueEntryLockAsync(queueEntry, cancellationToken).AnyContext(); if (lockValue == null) { await queueEntry.AbandonAsync().AnyContext(); _logger.Trace("Unable to acquire queue entry lock."); return(JobResult.Success); } try { LogProcessingQueueEntry(queueEntry); var result = await ProcessQueueEntryAsync(new QueueEntryContext <T>(queueEntry, lockValue, cancellationToken)).AnyContext(); if (!AutoComplete || queueEntry.IsCompleted || queueEntry.IsAbandoned) { return(result); } if (result.IsSuccess) { await queueEntry.CompleteAsync().AnyContext(); LogAutoCompletedQueueEntry(queueEntry); } else { await queueEntry.AbandonAsync().AnyContext(); _logger.Warn(() => $"Auto abandoned {_queueEntryName} queue entry ({queueEntry.Id})."); } return(result); } catch (Exception ex) { _logger.Error(ex, () => $"Error processing {_queueEntryName} queue entry ({queueEntry.Id})."); if (!queueEntry.IsCompleted && !queueEntry.IsAbandoned) { await queueEntry.AbandonAsync().AnyContext(); } throw; } finally { await lockValue.ReleaseAsync().AnyContext(); } }
public async Task <JobResult> RunAsync(CancellationToken cancellationToken = default(CancellationToken)) { var linkedCancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, TimeSpan.FromSeconds(30).ToCancellationToken()); IQueueEntry <WorkItemData> queueEntry; try { queueEntry = await _queue.DequeueAsync(linkedCancellationTokenSource.Token).AnyContext(); } catch (Exception ex) { return(JobResult.FromException(ex, $"Error trying to dequeue work item: {ex.Message}")); } if (queueEntry == null) { return(JobResult.Success); } if (cancellationToken.IsCancellationRequested) { _logger.Info("Job was cancelled. Abandoning {queueEntryType} work item: {queueEntryId}", queueEntry.Value.Type, queueEntry.Id); await queueEntry.AbandonAsync().AnyContext(); return(JobResult.CancelledWithMessage($"Abandoning {queueEntry.Value.Type} work item: {queueEntry.Id}")); } Type workItemDataType = null; try { workItemDataType = Type.GetType(queueEntry.Value.Type); } catch (Exception ex) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.FromException(ex, $"Could not resolve {workItemDataType.Name} work item data type.")); } if (workItemDataType == null) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.FailedWithMessage($"Could not resolve {workItemDataType.Name} work item data type.")); } object workItemData; try { workItemData = await _queue.Serializer.DeserializeAsync(queueEntry.Value.Data, workItemDataType).AnyContext(); } catch (Exception ex) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.FromException(ex, $"Failed to parse {workItemDataType.Name} work item data.")); } var handler = _handlers.GetHandler(workItemDataType); if (handler == null) { await queueEntry.CompleteAsync().AnyContext(); return(JobResult.FailedWithMessage($"Handler for type {workItemDataType.Name} not registered.")); } if (queueEntry.Value.SendProgressReports) { await _messageBus.PublishAsync(new WorkItemStatus { WorkItemId = queueEntry.Value.WorkItemId, Progress = 0, Type = queueEntry.Value.Type }).AnyContext(); } var lockValue = await handler.GetWorkItemLockAsync(workItemData, cancellationToken).AnyContext(); if (lockValue == null) { await queueEntry.AbandonAsync().AnyContext(); handler.Log.Trace("Unable to acquire work item lock."); return(JobResult.Success); } var progressCallback = new Func <int, string, Task>(async(progress, message) => { if (handler.AutoRenewLockOnProgress) { await queueEntry.RenewLockAsync().AnyContext(); } if (handler.AutoRenewLockOnProgress) { await lockValue.RenewAsync().AnyContext(); } await _messageBus.PublishAsync(new WorkItemStatus { WorkItemId = queueEntry.Value.WorkItemId, Progress = progress, Message = message, Type = queueEntry.Value.Type }).AnyContext(); }); try { handler.LogProcessingQueueEntry(queueEntry, workItemDataType, workItemData); await handler.HandleItemAsync(new WorkItemContext(workItemData, JobId, lockValue, cancellationToken, progressCallback)).AnyContext(); if (!queueEntry.IsAbandoned && !queueEntry.IsCompleted) { await queueEntry.CompleteAsync().AnyContext(); handler.LogAutoCompletedQueueEntry(queueEntry, workItemDataType, workItemData); } if (queueEntry.Value.SendProgressReports) { await _messageBus.PublishAsync(new WorkItemStatus { WorkItemId = queueEntry.Value.WorkItemId, Progress = 100, Type = queueEntry.Value.Type }).AnyContext(); } return(JobResult.Success); } catch (Exception ex) { if (!queueEntry.IsAbandoned && !queueEntry.IsCompleted) { await queueEntry.AbandonAsync().AnyContext(); } handler.Log.Error(ex, "Error processing {0} work item queue entry ({1}).", workItemDataType.Name, queueEntry.Id); return(JobResult.FromException(ex, $"Error in handler {workItemDataType.Name}.")); } finally { await lockValue.ReleaseAsync().AnyContext(); } }
public async Task <JobResult> ProcessAsync(IQueueEntry <WorkItemData> queueEntry, CancellationToken cancellationToken) { if (queueEntry == null) { return(JobResult.Success); } if (cancellationToken.IsCancellationRequested) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.CancelledWithMessage($"Abandoning {queueEntry.Value.Type} work item: {queueEntry.Id}")); } Type workItemDataType; try { workItemDataType = Type.GetType(queueEntry.Value.Type); } catch (Exception ex) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.FromException(ex, $"Abandoning {queueEntry.Value.Type} work item: {queueEntry.Id}: Could not resolve work item data type.")); } if (workItemDataType == null) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.FailedWithMessage($"Abandoning {queueEntry.Value.Type} work item: {queueEntry.Id}: Could not resolve work item data type.")); } object workItemData; try { workItemData = _queue.Serializer.Deserialize(queueEntry.Value.Data, workItemDataType); } catch (Exception ex) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.FromException(ex, $"Abandoning {queueEntry.Value.Type} work item: {queueEntry.Id}: Failed to parse {workItemDataType.Name} work item data.")); } var handler = _handlers.GetHandler(workItemDataType); if (handler == null) { await queueEntry.CompleteAsync().AnyContext(); return(JobResult.FailedWithMessage($"Completing {queueEntry.Value.Type} work item: {queueEntry.Id}: Handler for type {workItemDataType.Name} not registered.")); } if (queueEntry.Value.SendProgressReports) { await ReportProgressAsync(handler, queueEntry).AnyContext(); } var lockValue = await handler.GetWorkItemLockAsync(workItemData, cancellationToken).AnyContext(); if (lockValue == null) { if (handler.Log.IsEnabled(LogLevel.Information)) { handler.Log.LogInformation("Abandoning {TypeName} work item: {Id}: Unable to acquire work item lock.", queueEntry.Value.Type, queueEntry.Id); } await queueEntry.AbandonAsync().AnyContext(); return(JobResult.Success); } var progressCallback = new Func <int, string, Task>(async(progress, message) => { if (handler.AutoRenewLockOnProgress) { try { await Task.WhenAll( queueEntry.RenewLockAsync(), lockValue.RenewAsync() ).AnyContext(); } catch (Exception ex) { if (handler.Log.IsEnabled(LogLevel.Error)) { handler.Log.LogError(ex, "Error renewing work item locks: {Message}", ex.Message); } } } await ReportProgressAsync(handler, queueEntry, progress, message).AnyContext(); if (handler.Log.IsEnabled(LogLevel.Information)) { handler.Log.LogInformation("{TypeName} Progress {Progress}%: {Message}", workItemDataType.Name, progress, message); } }); try { handler.LogProcessingQueueEntry(queueEntry, workItemDataType, workItemData); await handler.HandleItemAsync(new WorkItemContext(workItemData, JobId, lockValue, cancellationToken, progressCallback)).AnyContext(); if (!queueEntry.IsAbandoned && !queueEntry.IsCompleted) { await queueEntry.CompleteAsync().AnyContext(); handler.LogAutoCompletedQueueEntry(queueEntry, workItemDataType, workItemData); } if (queueEntry.Value.SendProgressReports) { await ReportProgressAsync(handler, queueEntry, 100).AnyContext(); } return(JobResult.Success); } catch (Exception ex) { if (!queueEntry.IsAbandoned && !queueEntry.IsCompleted) { await queueEntry.AbandonAsync().AnyContext(); return(JobResult.FromException(ex, $"Abandoning {queueEntry.Value.Type} work item: {queueEntry.Id}: Error in handler {workItemDataType.Name}.")); } return(JobResult.FromException(ex, $"Error processing {queueEntry.Value.Type} work item: {queueEntry.Id} in handler: {workItemDataType.Name}")); } finally { await lockValue.ReleaseAsync().AnyContext(); } }
public async Task <JobResult> ProcessAsync(IQueueEntry <T> queueEntry, CancellationToken cancellationToken) { if (queueEntry == null) { return(JobResult.Success); } using (_logger.BeginScope(s => s .Property("QueueEntryId", queueEntry.Id) .PropertyIf("CorrelationId", queueEntry.CorrelationId, !String.IsNullOrEmpty(queueEntry.CorrelationId)) .Property("QueueEntryName", _queueEntryName))) { _logger.LogInformation("Processing queue entry: id={QueueEntryId} type={QueueEntryName} attempt={QueueEntryAttempt}", queueEntry.Id, _queueEntryName, queueEntry.Attempts); if (cancellationToken.IsCancellationRequested) { if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Job was cancelled. Abandoning {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } await queueEntry.AbandonAsync().AnyContext(); return(JobResult.CancelledWithMessage($"Abandoning {_queueEntryName} queue entry: {queueEntry.Id}")); } var lockValue = await GetQueueEntryLockAsync(queueEntry, cancellationToken).AnyContext(); if (lockValue == null) { await queueEntry.AbandonAsync().AnyContext(); _logger.LogTrace("Unable to acquire queue entry lock."); return(JobResult.Success); } bool isTraceLogLevelEnabled = _logger.IsEnabled(LogLevel.Trace); try { LogProcessingQueueEntry(queueEntry); var result = await ProcessQueueEntryAsync(new QueueEntryContext <T>(queueEntry, lockValue, cancellationToken)).AnyContext(); if (!AutoComplete || queueEntry.IsCompleted || queueEntry.IsAbandoned) { return(result); } if (result.IsSuccess) { await queueEntry.CompleteAsync().AnyContext(); LogAutoCompletedQueueEntry(queueEntry); } else { if (result.Error != null || result.Message != null) { _logger.LogError(result.Error, "{QueueEntryName} queue entry {Id} returned an unsuccessful response: {ErrorMessage}", _queueEntryName, queueEntry.Id, result.Message ?? result.Error?.Message); } if (isTraceLogLevelEnabled) { _logger.LogTrace("Processing was not successful. Auto Abandoning {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } await queueEntry.AbandonAsync().AnyContext(); if (_logger.IsEnabled(LogLevel.Warning)) { _logger.LogWarning("Auto abandoned {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } } return(result); } catch (Exception ex) { _logger.LogError(ex, "Error processing {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); if (!queueEntry.IsCompleted && !queueEntry.IsAbandoned) { await queueEntry.AbandonAsync().AnyContext(); } throw; } finally { if (isTraceLogLevelEnabled) { _logger.LogTrace("Releasing Lock for {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } await lockValue.ReleaseAsync().AnyContext(); if (isTraceLogLevelEnabled) { _logger.LogTrace("Released Lock for {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } } } }
public async Task <JobResult> ProcessAsync(IQueueEntry <T> queueEntry, CancellationToken cancellationToken) { if (queueEntry == null) { return(JobResult.Success); } if (cancellationToken.IsCancellationRequested) { if (_logger.IsEnabled(LogLevel.Information)) { _logger.LogInformation("Job was cancelled. Abandoning {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } await queueEntry.AbandonAsync().AnyContext(); return(JobResult.CancelledWithMessage($"Abandoning {_queueEntryName} queue entry: {queueEntry.Id}")); } var lockValue = await GetQueueEntryLockAsync(queueEntry, cancellationToken).AnyContext(); if (lockValue == null) { await queueEntry.AbandonAsync().AnyContext(); _logger.LogTrace("Unable to acquire queue entry lock."); return(JobResult.Success); } bool isTraceLogLevelEnabled = _logger.IsEnabled(LogLevel.Trace); try { LogProcessingQueueEntry(queueEntry); var result = await ProcessQueueEntryAsync(new QueueEntryContext <T>(queueEntry, lockValue, cancellationToken)).AnyContext(); if (!AutoComplete || queueEntry.IsCompleted || queueEntry.IsAbandoned) { return(result); } if (result.IsSuccess) { await queueEntry.CompleteAsync().AnyContext(); LogAutoCompletedQueueEntry(queueEntry); } else { if (isTraceLogLevelEnabled) { _logger.LogTrace("Processing was not successful. Auto Abandoning {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } await queueEntry.AbandonAsync().AnyContext(); if (_logger.IsEnabled(LogLevel.Warning)) { _logger.LogWarning("Auto abandoned {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } } return(result); } catch (Exception ex) { if (_logger.IsEnabled(LogLevel.Error)) { _logger.LogError(ex, "Error processing {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } if (!queueEntry.IsCompleted && !queueEntry.IsAbandoned) { await queueEntry.AbandonAsync().AnyContext(); } throw; } finally { if (isTraceLogLevelEnabled) { _logger.LogTrace("Releasing Lock for {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } await lockValue.ReleaseAsync().AnyContext(); if (isTraceLogLevelEnabled) { _logger.LogTrace("Released Lock for {QueueEntryName} queue entry: {Id}", _queueEntryName, queueEntry.Id); } } }
public async Task <JobResult> RunAsync(CancellationToken cancellationToken = new CancellationToken()) { var linkedCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, TimeSpan.FromSeconds(30).ToCancellationToken()); IQueueEntry <T> queueEntry; try { queueEntry = await _queue.DequeueAsync(linkedCancellationToken.Token).AnyContext(); } catch (Exception ex) { return(JobResult.FromException(ex, $"Error trying to dequeue message: {ex.Message}")); } if (queueEntry == null) { return(JobResult.Success); } if (cancellationToken.IsCancellationRequested) { _logger.Info(() => $"Job was cancelled. Abandoning {_queueEntryName} queue item: {queueEntry.Id}"); await queueEntry.AbandonAsync().AnyContext(); return(JobResult.CancelledWithMessage($"Abandoning {_queueEntryName} queue item: {queueEntry.Id}")); } var lockValue = await GetQueueEntryLockAsync(queueEntry, cancellationToken).AnyContext(); if (lockValue == null) { await queueEntry.AbandonAsync().AnyContext(); _logger.Trace("Unable to acquire queue entry lock."); return(JobResult.Success); } try { LogProcessingQueueEntry(queueEntry); var result = await ProcessQueueEntryAsync(new QueueEntryContext <T>(queueEntry, lockValue, cancellationToken)).AnyContext(); if (!AutoComplete || queueEntry.IsCompleted || queueEntry.IsAbandoned) { return(result); } if (result.IsSuccess) { await queueEntry.CompleteAsync().AnyContext(); LogAutoCompletedQueueEntry(queueEntry); } else { await queueEntry.AbandonAsync().AnyContext(); _logger.Warn(() => $"Auto abandoned {_queueEntryName} queue entry ({queueEntry.Id})."); } return(result); } catch (Exception ex) { _logger.Error(ex, () => $"Error processing {_queueEntryName} queue entry ({queueEntry.Id})."); if (!queueEntry.IsCompleted && !queueEntry.IsAbandoned) { await queueEntry.AbandonAsync().AnyContext(); } throw; } finally { await lockValue.ReleaseAsync().AnyContext(); } }