public void QueueRetry(IFullMessage message, TimeSpan delay)
{
_metrics.Increment("Retry Queue", Unit.Message);
var messageId = Guid.NewGuid().ToString();
message.Headers.TryGetValue(Headers.MessageId, out messageId);
Timer.Expire((state) =>
{
var msg = (IFullMessage)state;
_metrics.Decrement("Retry Queue", Unit.Message);
return(_dispatcher.SendLocal(msg));
}, message, delay, $"message {messageId}");
}
public async Task SendToError(Exception ex, IFullMessage message)
{
var transportTransaction = new TransportTransaction();
var messageBytes = _serializer.Serialize(message.Message);
var headers = new Dictionary <string, string>(message.Headers);
var errorContext = new ErrorContext(ex, headers,
Guid.NewGuid().ToString(),
messageBytes, transportTransaction,
int.MaxValue);
if ((await Bus.OnError(errorContext).ConfigureAwait(false)) != ErrorHandleResult.Handled)
{
throw new InvalidOperationException("Failed to send message error queue");
}
}
public Task Publish(IFullMessage message, IDictionary <string, string> headers = null)
{
Logger.Write(LogLevel.Debug, () => $"Publishing message of type [{message.Message.GetType().FullName}]");
var options = new PublishOptions();
if (headers != null)
{
foreach (var header in message.Headers.Merge(headers))
{
if (header.Key == Headers.OriginatingHostId)
{
//is added by bus in v5
continue;
}
options.SetHeader(header.Key, header.Value);
}
}
_metrics.Mark("Dispatched Messages", Unit.Message);
return(Bus.Instance.Publish(message.Message, options));
}
public async Task multiple_bulk_events()
{
var delayed = new Moq.Mock <IFullMessage>();
delayed.Setup(x => x.Headers).Returns(new Dictionary <string, string>
{
["test"] = "test",
[Defaults.ChannelKey] = "test"
});
var events = new IFullMessage[] { delayed.Object, delayed.Object, delayed.Object };
_contextBag.Set(Defaults.BulkHeader, events);
var headers = new Dictionary <string, string>();
_context.Setup(x => x.Headers).Returns(headers);
await _executor.Invoke(_context.Object, _next.Object);
_context.Verify(x => x.UpdateMessageInstance(Moq.It.IsAny <object>()), Moq.Times.Exactly(4));
_next.Verify(x => x(), Moq.Times.Exactly(3));
}
public async Task SendLocal(IFullMessage message, IDictionary <string, string> headers = null)
{
while (!Bus.BusOnline)
{
await Task.Delay(100).ConfigureAwait(false);
}
headers = headers ?? new Dictionary <string, string>();
var contextBag = new ContextBag();
// Hack to get all the events to invoker without NSB deserializing
contextBag.Set(Defaults.LocalHeader, message.Message);
var processed = false;
var numberOfDeliveryAttempts = 0;
var messageType = message.Message.GetType();
if (!messageType.IsInterface)
{
messageType = _mapper.GetMappedTypeFor(messageType) ?? messageType;
}
var finalHeaders = message.Headers.Merge(headers);
finalHeaders[Headers.EnclosedMessageTypes] = _registrar.GetVersionedName(messageType);
finalHeaders[Headers.MessageIntent] = MessageIntentEnum.Send.ToString();
var messageId = Guid.NewGuid().ToString();
var corrId = "";
if (finalHeaders.ContainsKey($"{Defaults.PrefixHeader}.{Defaults.MessageIdHeader}"))
{
messageId = finalHeaders[$"{Defaults.PrefixHeader}.{Defaults.MessageIdHeader}"];
}
if (finalHeaders.ContainsKey($"{Defaults.PrefixHeader}.{Defaults.CorrelationIdHeader}"))
{
corrId = finalHeaders[$"{Defaults.PrefixHeader}.{Defaults.CorrelationIdHeader}"];
}
Logger.DebugEvent("SendLocal", "Starting local message [{MessageId:l}] Corr [{CorrelationId:l}]", messageId, corrId);
finalHeaders[Headers.MessageId] = messageId;
finalHeaders[Headers.CorrelationId] = corrId;
while (!processed)
{
var transportTransaction = new TransportTransaction();
var tokenSource = new CancellationTokenSource();
try
{
var messageContext = new MessageContext(messageId,
finalHeaders,
Marker, transportTransaction, tokenSource,
contextBag);
await Bus.OnMessage(messageContext).ConfigureAwait(false);
_metrics.Mark("Dispatched Messages", Unit.Message);
processed = true;
}
catch (ObjectDisposedException)
{
// NSB transport has been disconnected
throw new OperationCanceledException();
}
catch (Exception ex)
{
_metrics.Mark("Dispatched Errors", Unit.Errors);
Logger.DebugEvent("SendLocalException", ex, "Local message [{MessageId:l}] Corr [{CorrelationId:l}] exception", messageId, corrId);
++numberOfDeliveryAttempts;
// Don't retry a cancelation
if (tokenSource.IsCancellationRequested)
{
numberOfDeliveryAttempts = Int32.MaxValue;
}
var messageBytes = _serializer.Serialize(message.Message);
var errorContext = new ErrorContext(ex, finalHeaders,
messageId,
messageBytes, transportTransaction,
numberOfDeliveryAttempts);
if ((await Bus.OnError(errorContext).ConfigureAwait(false)) ==
ErrorHandleResult.Handled || tokenSource.IsCancellationRequested)
{
break;
}
}
}
}
