public async Task <Message> Deserialize(TransportMessage transportMessage)
{
string contentEncoding;
if (!transportMessage.Headers.TryGetValue(Headers.ContentEncoding, out contentEncoding))
{
return(await _serializer.Deserialize(transportMessage));
}
if (contentEncoding != GzipEncodingHeader)
{
var message = $"The message {transportMessage.GetMessageLabel()} has a '{Headers.ContentEncoding}' with the" +
$" value '{contentEncoding}', but this serializer decorator only knows how to decompress" +
$" '{GzipEncodingHeader}'";
throw new ArgumentException(message);
}
var headers = transportMessage.Headers.Clone();
var compressedBody = transportMessage.Body;
headers.Remove(Headers.ContentEncoding);
var uncompressedBody = _zipper.Unzip(compressedBody);
var uncompressedTransportMessage = new TransportMessage(headers, uncompressedBody);
return(await _serializer.Deserialize(uncompressedTransportMessage));
}
static BrokeredMessage CreateBrokeredMessage(TransportMessage message)
{
var headers = message.Headers;
var brokeredMessage = new BrokeredMessage(new MemoryStream(message.Body), true);
foreach (var kvp in headers)
{
brokeredMessage.Properties[kvp.Key] = PossiblyLimitLength(kvp.Value);
}
if (headers.ContainsKey(Headers.TimeToBeReceived))
{
var timeToBeReceivedStr = headers[Headers.TimeToBeReceived];
var timeToBeReceived = TimeSpan.Parse(timeToBeReceivedStr);
brokeredMessage.TimeToLive = timeToBeReceived;
}
string contentType;
if (headers.TryGetValue(Headers.ContentType, out contentType))
{
brokeredMessage.ContentType = contentType;
}
string correlationId;
if (headers.TryGetValue(Headers.CorrelationId, out correlationId))
{
brokeredMessage.CorrelationId = correlationId;
}
brokeredMessage.Label = message.GetMessageLabel();
return(brokeredMessage);
}
public void HandleMessage(TransportMessage transportMessage, ITransactionContext transactionContext)
{
var message = transportMessage.GetMessageLabel();
var options = new List <KeyOption>();
if (DefaultOutputQueue != null)
{
options.Add(KeyOption.New('d',
() => { MoveMessage(transportMessage, transactionContext, DefaultOutputQueue); },
"Move to default queue '{0}'", DefaultOutputQueue));
}
if (transportMessage.Headers.ContainsKey(Headers.SourceQueue))
{
var sourceQueue = transportMessage.Headers[Headers.SourceQueue];
options.Add(KeyOption.New('s',
() => { MoveMessage(transportMessage, transactionContext, sourceQueue); },
"Return to source queue '{0}'", sourceQueue));
}
options.Add(KeyOption.New('c', () =>
{
Console.Write("queue > ");
var queueName = Console.ReadLine();
MoveMessage(transportMessage, transactionContext, queueName);
}, "Enter custom queue name to move message to"));
Prompt(message, options);
Text.PrintLine();
}
async Task ForwardMessageToExternalTimeoutManager(TransportMessage transportMessage, ITransactionContext transactionContext)
{
var timeoutManagerAddress = _options.ExternalTimeoutManagerAddressOrNull;
_log.Debug("Forwarding deferred message {messageLabel} to external timeout manager '{queueName}'",
transportMessage.GetMessageLabel(), timeoutManagerAddress);
await _transport.Send(timeoutManagerAddress, transportMessage, transactionContext);
}
async Task StoreMessageUntilDue(string deferredUntil, Dictionary <string, string> headers, TransportMessage transportMessage)
{
var approximateDueTime = GetTimeToBeDelivered(deferredUntil);
_log.Debug("Deferring message {messageLabel} until {dueTime}", transportMessage.GetMessageLabel(), approximateDueTime);
headers.Remove(Headers.DeferredUntil);
await _timeoutManager.Defer(approximateDueTime, headers, transportMessage.Body);
}
public string GetDebugInfo()
{
return(string.Join(Environment.NewLine, _timeoutManager
.Select(deferredMessage =>
{
var transportMessage = new TransportMessage(deferredMessage.Headers, deferredMessage.Body);
var label = transportMessage.GetMessageLabel();
return $"{deferredMessage.DueTime}: {label}";
})));
}
async Task SendTransportMessage(string destinationAddress, TransportMessage transportMessage)
{
var transactionContext = AmbientTransactionContext.Current;
if (transactionContext == null)
{
throw new InvalidOperationException($"Attempted to send {transportMessage.GetMessageLabel()} to {destinationAddress} outside of a transaction context!");
}
await _transport.Send(destinationAddress, transportMessage, transactionContext);
}
public async Task Send(string destinationAddress, TransportMessage message, ITransactionContext context)
{
for (var counter = 0; counter < 10; counter++)
{
Console.Write(".");
await Task.Delay(100);
}
Console.WriteLine($"Sending {message.GetMessageLabel()}");
await _transport.Send(destinationAddress, message, context);
}
async Task ProcessMessage(TransactionContext context, TransportMessage transportMessage)
{
try
{
context.Items["OwningBus"] = _owningBus;
AmbientTransactionContext.SetCurrent(context);
var incomingSteps = _pipeline.ReceivePipeline();
var stepContext = new IncomingStepContext(transportMessage, context);
await _pipelineInvoker.Invoke(stepContext, incomingSteps);
try
{
await context.Complete();
}
catch (Exception exception)
{
_log.Error(exception, "An error occurred when attempting to complete the transaction context");
}
}
catch (ThreadAbortException exception)
{
context.Abort();
_log.Error(exception, $"Worker was killed while handling message {transportMessage.GetMessageLabel()}");
}
catch (Exception exception)
{
context.Abort();
_log.Error(exception, $"Unhandled exception while handling message {transportMessage.GetMessageLabel()}");
}
finally
{
AmbientTransactionContext.SetCurrent(null);
}
}
static string GetMessageLabel(TransportMessage message)
{
try
{
return(message.GetMessageLabel());
}
catch
{
// if that failed, it's most likely because we're running in legacy mode - therefore:
return(message.Headers.GetValueOrNull(Headers.MessageId)
?? message.Headers.GetValueOrNull("rebus-msg-id")
?? "<unknown ID>");
}
}
public static BrokeredMessage CreateBrokeredMessage(TransportMessage message)
{
var headers = message.Headers.Clone();
var brokeredMessage = new BrokeredMessage(new MemoryStream(message.Body), true);
string timeToBeReceivedStr;
if (headers.TryGetValue(Headers.TimeToBeReceived, out timeToBeReceivedStr))
{
timeToBeReceivedStr = headers[Headers.TimeToBeReceived];
var timeToBeReceived = TimeSpan.Parse(timeToBeReceivedStr);
brokeredMessage.TimeToLive = timeToBeReceived;
}
string deferUntilTime;
if (headers.TryGetValue(Headers.DeferredUntil, out deferUntilTime))
{
var deferUntilDateTimeOffset = deferUntilTime.ToDateTimeOffset();
brokeredMessage.ScheduledEnqueueTimeUtc = deferUntilDateTimeOffset.UtcDateTime;
headers.Remove(Headers.DeferredUntil);
}
string contentType;
if (headers.TryGetValue(Headers.ContentType, out contentType))
{
brokeredMessage.ContentType = contentType;
}
string correlationId;
if (headers.TryGetValue(Headers.CorrelationId, out correlationId))
{
brokeredMessage.CorrelationId = correlationId;
}
brokeredMessage.Label = message.GetMessageLabel();
foreach (var kvp in headers)
{
brokeredMessage.Properties[kvp.Key] = PossiblyLimitLength(kvp.Value);
}
return(brokeredMessage);
}
async Task ProcessMessage(TransactionContext context, TransportMessage transportMessage)
{
try
{
AmbientTransactionContext.SetCurrent(context);
var stepContext = new IncomingStepContext(transportMessage, context);
stepContext.Save(_busDisposalCancellationToken);
await _pipelineInvoker.Invoke(stepContext);
try
{
await context.Complete();
}
catch (Exception exception)
{
_log.Error(exception, "An error occurred when attempting to complete the transaction context");
}
}
catch (OperationCanceledException exception)
{
context.Abort();
_log.Error(exception, "Worker was aborted while handling message {messageLabel}", transportMessage.GetMessageLabel());
}
catch (Exception exception)
{
context.Abort();
_log.Error(exception, "Unhandled exception while handling message {messageLabel}", transportMessage.GetMessageLabel());
}
finally
{
AmbientTransactionContext.SetCurrent(null);
}
}
async Task ProcessMessage(TransactionContext context, TransportMessage transportMessage)
{
try
{
context.Items["OwningBus"] = _owningBus;
AmbientTransactionContext.SetCurrent(context);
var stepContext = new IncomingStepContext(transportMessage, context);
await _pipelineInvoker.Invoke(stepContext);
try
{
await context.Complete();
}
catch (Exception exception)
{
_log.Error(exception, "An error occurred when attempting to complete the transaction context");
}
}
#if NET45
catch (ThreadAbortException exception)
#elif NETSTANDARD1_3
catch (OperationCanceledException exception)
#endif
{
context.Abort();
_log.Error(exception, "Worker was killed while handling message {messageLabel}", transportMessage.GetMessageLabel());
}
catch (Exception exception)
{
context.Abort();
_log.Error(exception, "Unhandled exception while handling message {messageLabel}", transportMessage.GetMessageLabel());
}
finally
{
AmbientTransactionContext.SetCurrent(null);
}
}
