private async Task ProcessPublishedAsync(IStorageConnection connection, ProcessingContext context) { var messages = await connection.GetFailedPublishedMessages(); var hasException = false; foreach (var message in messages) { if (!hasException) { try { _options.FailedCallback?.Invoke(Models.MessageType.Publish, message.Name, message.Content); } catch (Exception ex) { hasException = true; _logger.LogWarning("Failed call-back method raised an exception:" + ex.Message); } } using (var transaction = connection.CreateTransaction()) { _stateChanger.ChangeState(message, new EnqueuedState(), transaction); await transaction.CommitAsync(); } context.ThrowIfStopping(); await context.WaitAsync(_delay); } }
private async Task ProcessPublishedAsync(IStorageConnection connection, ProcessingContext context) { var messages = await connection.GetFailedPublishedMessages(); foreach (var message in messages) { using (var transaction = connection.CreateTransaction()) { _stateChanger.ChangeState(message, new EnqueuedState(), transaction); await transaction.CommitAsync(); } context.ThrowIfStopping(); await context.WaitAsync(_delay); } }
private async Task ProcessPublishedAsync(IStorageConnection connection, ProcessingContext context) { var messages = await connection.GetFailedPublishedMessages(); var hasException = false; foreach (var message in messages) { if (message.Retries > _options.FailedRetryCount) { continue; } if (!hasException) { try { _options.FailedCallback?.Invoke(MessageType.Publish, message.Name, message.Content); } catch (Exception ex) { hasException = true; _logger.LogWarning("Failed call-back method raised an exception:" + ex.Message); } } using (var transaction = connection.CreateTransaction()) { try { await _publishExecutor.PublishAsync(message.Name, message.Content); _stateChanger.ChangeState(message, new SucceededState(), transaction); } catch (Exception e) { message.Content = Helper.AddExceptionProperty(message.Content, e); message.Retries++; transaction.UpdateMessage(message); } await transaction.CommitAsync(); } context.ThrowIfStopping(); await context.WaitAsync(_delay); } }
public async Task ProcessAsync(ProcessingContext context) { _logger.LogDebug("Publish Queuer start calling."); using (var scope = _provider.CreateScope()) { CapPublishedMessage sentMessage; var provider = scope.ServiceProvider; var connection = provider.GetRequiredService <IStorageConnection>(); while ( !context.IsStopping && (sentMessage = await connection.GetNextPublishedMessageToBeEnqueuedAsync()) != null) { var state = new EnqueuedState(); using (var transaction = connection.CreateTransaction()) { _stateChanger.ChangeState(sentMessage, state, transaction); await transaction.CommitAsync(); } } } context.ThrowIfStopping(); DefaultDispatcher.PulseEvent.Set(); await WaitHandleEx.WaitAnyAsync(PulseEvent, context.CancellationToken.WaitHandle, _pollingDelay); }
public async Task ProcessAsync(ProcessingContext context) { using (var scope = _provider.CreateScope()) { Job job; var provider = scope.ServiceProvider; var connection = provider.GetRequiredService <IStorageConnection>(); while ( !context.IsStopping && (job = await connection.GetNextJobToBeEnqueuedAsync()) != null) { var state = new EnqueuedState(); using (var transaction = connection.CreateTransaction()) { _stateChanger.ChangeState(job, state, transaction); await transaction.CommitAsync(); } } } context.ThrowIfStopping(); DelayedJobProcessor.PulseEvent.Set(); await WaitHandleEx.WaitAnyAsync(PulseEvent, context.CancellationToken.WaitHandle, _pollingDelay); }
public static async Task ChangeStateAsync( this IStateChanger @this, CapReceivedMessage message, IState state, IStorageConnection connection) { using (var transaction = connection.CreateTransaction()) { @this.ChangeState(message, state, transaction); await transaction.CommitAsync(); } }
public static async Task ChangeStateAsync( this IStateChanger @this, Job job, IState state, IStorageConnection connection) { using (var transaction = connection.CreateTransaction()) { @this.ChangeState(job, state, transaction); await transaction.CommitAsync(); } }
public void nextLevelUpdate() { foreach (var item in level.BlokArray) { Tile temptile = (Tile)collidy.ReturnCollision(player, (ICollidable)item); if (temptile != null && temptile.IsPortal) { skip = true; } } if (skip) { for (int x = 0; x < 14; x++) { for (int y = 0; y < 15; y++) { level.BlokArray[x, y] = null; } } level.levelbinder.Level++; if (level.levelbinder.Level >= level.levelbinder.AllLevels.Count) { stateChanger.ChangeState(new EndState(stateChanger, graphicsDevice, content)); goto end; } level.CreateWorld(); lava.CreateWorld(); player.position = player.originalPosition; skip = false; } end :; }
private async Task ProcessPublishedAsync(IStorageConnection connection, ProcessingContext context) { var messages = await connection.GetPublishedMessagesOfNeedRetry(); var hasException = false; foreach (var message in messages) { if (message.Retries > _options.FailedRetryCount) { continue; } using (var transaction = connection.CreateTransaction()) { var result = await _publishExecutor.PublishAsync(message.Name, message.Content); if (result.Succeeded) { _stateChanger.ChangeState(message, new SucceededState(), transaction); _logger.LogInformation("The message was sent successfully during the retry. MessageId:" + message.Id); } else { message.Content = Helper.AddExceptionProperty(message.Content, result.Exception); message.Retries++; if (message.StatusName == StatusName.Scheduled) { message.ExpiresAt = GetDueTime(message.Added, message.Retries); message.StatusName = StatusName.Failed; } transaction.UpdateMessage(message); if (message.Retries >= _options.FailedRetryCount) { _logger.LogError($"The message still sent failed after {_options.FailedRetryCount} retries. We will stop retrying the message. " + "MessageId:" + message.Id); if (message.Retries == _options.FailedRetryCount) { if (!hasException) { try { _options.FailedThresholdCallback?.Invoke(MessageType.Publish, message.Name, message.Content); } catch (Exception ex) { hasException = true; _logger.LogWarning("Failed call-back method raised an exception:" + ex.Message); } } } } } await transaction.CommitAsync(); } context.ThrowIfStopping(); await context.WaitAsync(_delay); } }