async Task IMessageSessionAsyncHandler.OnMessageAsync(MessageSession session, BrokeredMessage message)
{
if (_receiver.IsShuttingDown)
{
await WaitAndAbandonMessage(message).ConfigureAwait(false);
return;
}
using (var delivery = _tracker.BeginDelivery())
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receiving {0}:{1}({3}) - {2}", delivery.Id, message.MessageId, _receiver.QueuePath, session.SessionId);
}
var context = new ServiceBusReceiveContext(_receiver.InputAddress, message, _context, _sendEndpointProvider, _publishEndpointProvider);
context.GetOrAddPayload <MessageSessionContext>(() => new BrokeredMessageSessionContext(session));
context.GetOrAddPayload(() => _context);
try
{
await _context.PreReceive(context).ConfigureAwait(false);
await _receiver.ReceivePipe.Send(context).ConfigureAwait(false);
await context.CompleteTask.ConfigureAwait(false);
await message.CompleteAsync().ConfigureAwait(false);
await _context.PostReceive(context).ConfigureAwait(false);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receive completed: {0}", message.MessageId);
}
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.Error($"Received faulted: {message.MessageId}", ex);
}
await message.AbandonAsync().ConfigureAwait(false);
await _context.ReceiveFault(context, ex).ConfigureAwait(false);
}
finally
{
context.Dispose();
}
}
}
async Task IMessageSessionAsyncHandler.OnMessageAsync(MessageSession session, BrokeredMessage message)
{
if (_receiver.IsShuttingDown)
{
await WaitAndAbandonMessage(message).ConfigureAwait(false);
return;
}
using (var delivery = _tracker.BeginDelivery())
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Receiving {0}:{1}({3}) - {2}", delivery.Id, message.MessageId, _receiver.QueuePath, session.SessionId);
var context = new ServiceBusReceiveContext(_receiver.InputAddress, message, _context, _sendEndpointProvider, _publishEndpointProvider);
context.GetOrAddPayload<MessageSessionContext>(() => new BrokeredMessageSessionContext(session));
context.GetOrAddPayload(() => _context);
try
{
await _context.PreReceive(context).ConfigureAwait(false);
await _receiver.ReceivePipe.Send(context).ConfigureAwait(false);
await context.CompleteTask.ConfigureAwait(false);
await message.CompleteAsync().ConfigureAwait(false);
await _context.PostReceive(context).ConfigureAwait(false);
if (_log.IsDebugEnabled)
_log.DebugFormat("Receive completed: {0}", message.MessageId);
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
_log.Error($"Received faulted: {message.MessageId}", ex);
await message.AbandonAsync().ConfigureAwait(false);
await _context.ReceiveFault(context, ex).ConfigureAwait(false);
}
finally
{
context.Dispose();
}
}
}
async Task IMessageSessionAsyncHandler.OnMessageAsync(MessageSession session, BrokeredMessage message)
{
if (_receiver.IsShuttingDown)
{
await WaitAndAbandonMessage(message).ConfigureAwait(false);
return;
}
var deliveryCount = _receiver.IncrementDeliveryCount();
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receiving {0}:{1}({3}) - {2}", deliveryCount, message.MessageId, _receiver.QueuePath, session.SessionId);
}
var context = new ServiceBusReceiveContext(_receiver.InputAddress, message, _receiver.ReceiveObserver);
context.GetOrAddPayload <MessageSessionContext>(() => new BrokeredMessageSessionContext(session));
try
{
await _receiver.ReceiveObserver.PreReceive(context).ConfigureAwait(false);
await _receiver.ReceivePipe.Send(context).ConfigureAwait(false);
await context.CompleteTask.ConfigureAwait(false);
await message.CompleteAsync().ConfigureAwait(false);
await _receiver.ReceiveObserver.PostReceive(context).ConfigureAwait(false);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receive completed: {0}", message.MessageId);
}
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.Error($"Received faulted: {message.MessageId}", ex);
}
await message.AbandonAsync().ConfigureAwait(false);
await _receiver.ReceiveObserver.ReceiveFault(context, ex).ConfigureAwait(false);
}
finally
{
_receiver.DeliveryComplete();
}
}
async Task IMessageSessionAsyncHandler.OnMessageAsync(MessageSession session, BrokeredMessage message)
{
if (_receiver.IsShuttingDown)
{
await WaitAndAbandonMessage(message).ConfigureAwait(false);
return;
}
var deliveryCount = _receiver.IncrementDeliveryCount();
if (_log.IsDebugEnabled)
_log.DebugFormat("Receiving {0}:{1}({3}) - {2}", deliveryCount, message.MessageId, _receiver.QueuePath, session.SessionId);
var context = new ServiceBusReceiveContext(_receiver.InputAddress, message, _receiver.ReceiveObserver);
context.GetOrAddPayload<MessageSessionContext>(() => new BrokeredMessageSessionContext(session));
try
{
await _receiver.ReceiveObserver.PreReceive(context).ConfigureAwait(false);
await _receiver.ReceivePipe.Send(context).ConfigureAwait(false);
await context.CompleteTask.ConfigureAwait(false);
await message.CompleteAsync().ConfigureAwait(false);
await _receiver.ReceiveObserver.PostReceive(context).ConfigureAwait(false);
if (_log.IsDebugEnabled)
_log.DebugFormat("Receive completed: {0}", message.MessageId);
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
_log.Error($"Received faulted: {message.MessageId}", ex);
await message.AbandonAsync().ConfigureAwait(false);
await _receiver.ReceiveObserver.ReceiveFault(context, ex).ConfigureAwait(false);
}
finally
{
_receiver.DeliveryComplete();
}
}
async Task OnMessage(BrokeredMessage message)
{
if (_shuttingDown)
{
await WaitAndAbandonMessage(message).ConfigureAwait(false);
return;
}
using (var delivery = _tracker.BeginDelivery())
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receiving {0}:{1} - {2}", delivery.Id, message.MessageId, _clientSettings.Path);
}
var context = new ServiceBusReceiveContext(_clientContext.InputAddress, message, _context, _topology);
context.GetOrAddPayload(() => _context);
try
{
await _context.PreReceive(context).ConfigureAwait(false);
if (message.LockedUntilUtc <= DateTime.UtcNow)
{
throw new MessageLockExpiredException(_clientContext.InputAddress, $"The message lock expired: {message.MessageId}");
}
if (message.ExpiresAtUtc < DateTime.UtcNow)
{
throw new MessageTimeToLiveExpiredException(_clientContext.InputAddress, $"The message TTL expired: {message.MessageId}");
}
await _receivePipe.Send(context).ConfigureAwait(false);
await context.CompleteTask.ConfigureAwait(false);
await message.CompleteAsync().ConfigureAwait(false);
await _context.PostReceive(context).ConfigureAwait(false);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receive completed: {0}", message.MessageId);
}
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.Error($"Received faulted: {message.MessageId}", ex);
}
await AbandonMessage(message).ConfigureAwait(false);
await _context.ReceiveFault(context, ex).ConfigureAwait(false);
}
finally
{
context.Dispose();
}
}
}
async Task OnMessage(BrokeredMessage message)
{
if (_shuttingDown)
{
await WaitAndAbandonMessage(message).ConfigureAwait(false);
return;
}
var current = Interlocked.Increment(ref _currentPendingDeliveryCount);
while (current > _maxPendingDeliveryCount)
{
Interlocked.CompareExchange(ref _maxPendingDeliveryCount, current, _maxPendingDeliveryCount);
}
var deliveryCount = Interlocked.Increment(ref _deliveryCount);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receiving {0}:{1} - {2}", deliveryCount, message.MessageId, _receiveSettings.QueueDescription.Path);
}
var context = new ServiceBusReceiveContext(_inputAddress, message, _receiveObserver);
context.GetOrAddPayload(() => _context);
try
{
await _receiveObserver.PreReceive(context).ConfigureAwait(false);
await _receivePipe.Send(context).ConfigureAwait(false);
await context.CompleteTask.ConfigureAwait(false);
await message.CompleteAsync().ConfigureAwait(false);
await _receiveObserver.PostReceive(context).ConfigureAwait(false);
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receive completed: {0}", message.MessageId);
}
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
{
_log.Error($"Received faulted: {message.MessageId}", ex);
}
await message.AbandonAsync().ConfigureAwait(false);
await _receiveObserver.ReceiveFault(context, ex).ConfigureAwait(false);
}
finally
{
var pendingCount = Interlocked.Decrement(ref _currentPendingDeliveryCount);
if (pendingCount == 0 && _shuttingDown)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Receiver shutdown completed: {0}", _inputAddress);
}
_participant.SetComplete();
}
}
}
async Task OnMessage(BrokeredMessage message)
{
if (_shuttingDown)
{
await WaitAndAbandonMessage(message).ConfigureAwait(false);
return;
}
var current = Interlocked.Increment(ref _currentPendingDeliveryCount);
while (current > _maxPendingDeliveryCount)
Interlocked.CompareExchange(ref _maxPendingDeliveryCount, current, _maxPendingDeliveryCount);
var deliveryCount = Interlocked.Increment(ref _deliveryCount);
if (_log.IsDebugEnabled)
_log.DebugFormat("Receiving {0}:{1} - {2}", deliveryCount, message.MessageId, _receiveSettings.QueueDescription.Path);
var context = new ServiceBusReceiveContext(_inputAddress, message, _receiveObserver);
context.GetOrAddPayload(() => _context);
try
{
await _receiveObserver.PreReceive(context).ConfigureAwait(false);
await _receivePipe.Send(context).ConfigureAwait(false);
await context.CompleteTask.ConfigureAwait(false);
await message.CompleteAsync().ConfigureAwait(false);
await _receiveObserver.PostReceive(context).ConfigureAwait(false);
if (_log.IsDebugEnabled)
_log.DebugFormat("Receive completed: {0}", message.MessageId);
}
catch (Exception ex)
{
if (_log.IsErrorEnabled)
_log.Error($"Received faulted: {message.MessageId}", ex);
await message.AbandonAsync().ConfigureAwait(false);
await _receiveObserver.ReceiveFault(context, ex).ConfigureAwait(false);
}
finally
{
var pendingCount = Interlocked.Decrement(ref _currentPendingDeliveryCount);
if (pendingCount == 0 && _shuttingDown)
{
if (_log.IsDebugEnabled)
_log.DebugFormat("Receiver shutdown completed: {0}", _inputAddress);
_participant.SetComplete();
}
}
}
