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);
}
}
