protected override async Task <TransportMessage> ReadMessage(bool isPrimaryReader, long taskId, CancellationToken token, ITransactionContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context), "ITransactionContext context == null");
}
TransportMessage msg;
try
{
msg = await _transport.Receive(context, token);
}
catch (OperationCanceledException)
{
// it's fine - just a sign that we are shutting down
throw;
}
catch (Exception exception)
{
Log.Warn("An error occurred when attempting to receive the next message: {exception}", exception);
if (IsPrimaryReader)
{
await _backoffStrategy.WaitErrorAsync(token);
}
return(null);
}
token.ThrowIfCancellationRequested();
return(msg);
}
private async Task ProcessOutboxMessages()
{
_log.Debug("Starting outbox messages processor");
while (!_busDisposalCancellationToken.IsCancellationRequested)
{
try
{
bool waitForMessages;
using (var transactionScope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
var messages = await _outboxStorage.Retrieve(_busDisposalCancellationToken, _topMessagesToRetrieve);
if (messages.Length > 0)
{
using (var rebusTransactionScope = new RebusTransactionScope())
{
foreach (var message in messages)
{
var destinationAddress = message.Headers[OutboxHeaders.Recipient];
message.Headers.Remove(OutboxHeaders.Recipient);
await _transport.Send(destinationAddress, message,
rebusTransactionScope.TransactionContext);
}
await rebusTransactionScope.CompleteAsync();
}
waitForMessages = false;
}
else
{
waitForMessages = true;
}
transactionScope.Complete();
}
if (waitForMessages)
{
await _backoffStrategy.WaitNoMessageAsync(_busDisposalCancellationToken);
}
else
{
_backoffStrategy.Reset();
}
}
catch (OperationCanceledException) when(_busDisposalCancellationToken.IsCancellationRequested)
{
// we're shutting down
}
catch (Exception exception)
{
_log.Error(exception, "Unhandled exception in outbox messages processor");
await _backoffStrategy.WaitErrorAsync(_busDisposalCancellationToken);
}
}
_log.Debug("Outbox messages processor stopped");
}
private async Task _processOutboxMessages(CancellationToken ctk)
{
_log.Debug("Starting outbox messages processor");
while (!ctk.IsCancellationRequested)
{
try
{
bool waitForMessages = true;
using (var ctx = _outboxContextFactory.Create())
{
var messages = await ctx.PeekLockMessagesAsync(_topMessagesToRetrieve, ctk);
if (messages.Any())
{
using (var rebusTransactionScope = new RebusTransactionScope())
{
foreach (var message in messages)
{
var destinationAddress = message.Headers[OutboxTransportDecorator._outboxRecepientHeader];
message.Headers.Remove(OutboxTransportDecorator._outboxRecepientHeader);
await _transport.Send(destinationAddress, new TransportMessage(message.Headers, message.Body),
rebusTransactionScope.TransactionContext).WithCancellation(ctk);
}
await rebusTransactionScope.CompleteAsync().WithCancellation(ctk);
}
waitForMessages = false;
_backoffStrategy.Reset();
}
ctx.Commit();
}
if (waitForMessages)
{
await _backoffStrategy.WaitNoMessageAsync(ctk);
}
}
catch (OperationCanceledException) when(ctk.IsCancellationRequested)
{
// we're shutting down
}
catch (Exception exception)
{
_log.Error(exception, "Unhandled exception in outbox messages processor");
await _backoffStrategy.WaitErrorAsync(ctk);
}
}
_log.Debug("Outbox messages processor stopped");
}
async Task <TransportMessage> ReceiveTransportMessage(CancellationToken token, ITransactionContext context)
{
try
{
return(await _transport.Receive(context, token));
}
catch (OperationCanceledException) when(token.IsCancellationRequested || _busDisposalCancellationToken.IsCancellationRequested)
{
// it's fine - just a sign that we are shutting down
return(null);
}
catch (Exception exception)
{
_log.Warn("An error occurred when attempting to receive the next message: {exception}", exception);
await _backoffStrategy.WaitErrorAsync(token);
return(null);
}
}