public async Task Handle(IFailed <Object> message)
{
Console.WriteLine("Handle(IFailed<Object> message): {0}", message);
await _bus.Advanced.TransportMessage.Defer(TimeSpan.FromSeconds(2));
_hasDeferredMessage.Set();
}
public async Task Handle(IFailed <Exception> message)
{
await this.Bus.Advanced.Routing.Send(
"ErrorThrownQueue",
message.ErrorDescription
);
}
public async Task Handle(IFailed <GenerateProductVariant> messageWrapper)
{
await _bus.Publish(new ProductVariantGenerationFailed(
orderId : messageWrapper.Message.OrderId,
errorDescription : messageWrapper.ErrorDescription
));
_callsToSecondLevelHandler.Enqueue($"called at {DateTime.UtcNow.Ticks} tickerinos");
}
public Task Handle(IFailed <GenerateProductVariant> messageWrapper)
{
Log.Debug("Product variant generation failed. product_variant_name={0}", messageWrapper.Message.ProductVariant);
return(_bus.Publish(new ProductVariantGenerationFailed
{
OrderId = messageWrapper.Message.OrderId,
ErrorDescription = messageWrapper.ErrorDescription
}));
}
public static async Task ExponentialRetry <T>(this IBus bus, IFailed <T> failedMessage, int maxRetries)
{
if (failedMessage.Headers.TryGetValue(Headers.CorrelationSequence, out string seq) && Int32.TryParse(seq, out int retries) && maxRetries + 2 >= retries)
{
retries -= 2;
TimeSpan delay = RetryDelays.Length >= retries ? RetryDelays[retries] : RetryDelays.Last();
await bus.Defer(delay, failedMessage.Message);
}
}
public async Task Handle(IFailed <PlatformUserUpdateDataMessage> message)
{
if (message.Exceptions.Any(e => e.GetType() == typeof(CacheDataNotFoundException)))
{
throw new ApplicationException();
}
_logger.LogInformation($"Handling failed {nameof(PlatformUserUpdateDataMessage)}. Will defer 60 seconds");
await _bus.DeferLocal(TimeSpan.FromSeconds(60), message.Message);
}
public async Task Handle(IFailed <SendTransactionalEmail> message)
{
await this.Bus.Advanced.Routing.Send(
"ErrorThrownQueue",
new ErrorThrown
{
MessageName = "SendTransactionalEmail",
ErrorDesc = message.ErrorDescription,
Timestamp = DateTime.Now
}
);
}
public async Task Handle(IFailed <YourMessage> message)
{
_callback("Handle IFailed<YourMessage> and defer");
_whatToDo.ShouldFail = false;
// this would defer the message with a new ID, so we would not recognize the message when it returned
//await _bus.Defer(TimeSpan.FromSeconds(1), message.Message);
// to check that we clear the state as we should, we must defer the actual transport message
await _bus.Advanced.TransportMessage.Defer(TimeSpan.FromSeconds(1));
}
public async Task Handle(IFailed <CancelReservationExtended> message)
{
await this.Bus.Advanced.Routing.Send(
"ErrorThrownQueue",
new ErrorThrown
{
MessageName = "CancelReservation",
ErrorDesc = message.ErrorDescription,
Timestamp = DateTime.Now
}
);
}
public Task Handle(IFailed <TestMessage> message)
{
var deferCount = Convert.ToInt32(_messageContext.Headers.GetValueOrDefault(Headers.DeferCount));
var messageId = _messageContext.TransportMessage.GetMessageId();
if (deferCount >= 3)
{
Console.WriteLine($"Defer count: {deferCount}, manually dead-lettering (msg id {messageId})");
return(_transportMessageApi.Deadletter($"Failed after {deferCount} attempts\n\n{message.ErrorDescription}"));
}
Console.WriteLine($"Defer count: {deferCount}, delay seconds: 1 (msg id {messageId})");
return(_transportMessageApi.Defer(TimeSpan.FromSeconds(1)));
}
public async Task Handle(IFailed <DataFetchCompleteMessage> message)
{
using var _ = _logger.BeginNamedScopeWithMessage(nameof(DataFetchCompleteHandler),
_messageContext.Message.GetMessageId(),
(LoggerPropertyNames.PlatformId, message.Message.PlatformId),
(LoggerPropertyNames.UserId, message.Message.UserId));
var topException = message.Exceptions.FirstOrDefault();
var deferTime = TimeSpan.FromSeconds(60);
_logger.LogError(topException, "Handling of message failed. Will defer from {deferTime} seconds and try again.", deferTime);
await _bus.DeferLocal(deferTime, message.Message);
}
public Task Handle(IFailed <CancelReservationExtended> message)
{
Form.Errors.Add
(
new ErrorThrown
{
MessageName = "CancelReservationExtended",
Timestamp = DateTime.Now,
ErrorDesc = message.ErrorDescription
}
);
return(Task.CompletedTask);
}
public async Task Handle(IFailed <string> message)
{
const int maxDeferCount = 2;
var deferCount = Convert.ToInt32(message.Headers.GetValueOrDefault(Headers.DeferCount));
Console.WriteLine($"Handling failed message for the {deferCount + 1}st time");
if (deferCount >= maxDeferCount)
{
Console.WriteLine($"Sending the failed message to the error queue");
await _bus.Advanced.TransportMessage.Deadletter($"Failed after {deferCount} deferrals\n\n{message.ErrorDescription}");
return;
}
await _bus.Advanced.TransportMessage.Defer(TimeSpan.FromSeconds(30));
}
public Task Handle(IFailed <BaseMessage> message)
{
throw new System.NotImplementedException();
}
public async Task Handle(IFailed <SomeMessage> message)
{
}
public async Task Handle(IFailed <string> message) => _gotTheFailedMessage.Set();
public Task Handle(IFailed <Mensagem> erro)
{
logger.LogInformation($"Erro: {erro.Message.Nome}");
return(Task.CompletedTask);
}
public Task Handle(IFailed <EvaluateSuggestionCommand> message)
{
return(_bus.ExponentialRetry(message, 3));
}
public async Task Handle(IFailed <BaseMessage> message) => _gotTheFailedMessage.Set();
public async Task Handle(IFailed <InventoryItemRenamed> failed)
{
await _bus.Defer(TimeSpan.FromMinutes(1), failed.Message);
}
public async Task Handle(IFailed <Job> failedMessage)
{
await bus.Advanced.TransportMessage.Defer(TimeSpan.FromSeconds(30));
}
public Task Handle(IFailed <object> message) => Task.CompletedTask;
public async Task Handle(IFailed <PlatformConnectionRemovedMessage> message)
{
await _bus.DeferLocal(TimeSpan.FromSeconds(60), message.Message);
}
public Task Handle(IFailed <ObjectsInAmsterdamPulled> message)
{
_logger.LogInformation("Message received: ObjectsInAmsterdamPulled with error");
_logger.LogInformation("Sending information to the clients: transfer.objectsInAmsterdamPulled.Error");
return(_hub.Clients.All.SendAsync("transfer.objectsInAmsterdamPulled.Error"));
}
public async Task Handle(IFailed <ItemsRemovedFromInventory> failed)
{
await _bus.Defer(TimeSpan.FromMinutes(1), failed.Message);
}
public async Task Handle(IFailed <SomeMessageThatFails> message)
{
Data.CorrelationId = message.Message.CorrelationId;
_counter.Decrement();
}
public async Task Handle(IFailed <ISagaMessage> message)
{
_logger.Error("Unable to handle the message of type {msgtype} with error message {errMsg}", message.Message.GetType().Name, message.ErrorDescription);
}
public Task Handle(IFailed <FailedMessage> message)
{
throw new NotImplementedException();
}
public Task Handle(IFailed <PlatformConnectionUpdateNotificationMessage> message)
{
throw new NotImplementedException();
}
public async Task Handle(IFailed <TestMessage> message)
{
Data.Text = message.Message.Text;
_gotFailedMessage.Set();
}
public void ActionFailed(IFailed evt)
{
EntityAction<ActionParameters> action = evt.Action as EntityAction<ActionParameters>;
if (action != null)
{
Console.WriteLine("-- RemoteCharacter.ActionFailed " + action.Name);
if (this.receiverAlive)
{
Send(ACTION_FAILED + " " + action.StartArguments.ToXML());
}
}
}
