public async Task CloseAsync(CancellationToken cancellationToken)
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Closing client: {0}", InputAddress);
}
try
{
if (_messageReceiver != null && !_messageReceiver.IsClosedOrClosing)
{
await _messageReceiver.CloseAsync().ConfigureAwait(false);
}
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Closed client: {0}", InputAddress);
}
}
catch (Exception exception)
{
if (_log.IsWarnEnabled)
{
_log.Warn($"Exception closing the client: {InputAddress}", exception);
}
}
}
private async Task <IEnumerable <DeadLetter> > ReadDeadLettersFromServiceBusAsync(string serviceBusQueue)
{
ConcurrentBag <DeadLetter> _deadLetters = new ConcurrentBag <DeadLetter>();
IMessageReceiver messageReceiver = _messageReceiverFactory.Create(serviceBusQueue, ReceiveMode.PeekLock, true);
IList <Message> messages = await messageReceiver.PeekAsync(MaxMessageCount);
await messageReceiver.CloseAsync();
foreach (Message message in messages)
{
// Process the message
var deadletter = new DeadLetter(_messageReader.ReadMessage(Encoding.UTF8.GetString(message.Body)))
{
MessageDate = message.SystemProperties.EnqueuedTimeUtc,
DeadLetterReason = message.UserProperties["DeadLetterReason"].ToString(),
DeadLetterErrorDescription = message.UserProperties["DeadLetterErrorDescription"].ToString(),
SequenceNumber = message.SystemProperties.SequenceNumber,
SubscriptionName = serviceBusQueue
};
_deadLetters.Add(deadletter);
}
return(_deadLetters);
}
public static async Task CloseReceiver(IMessageReceiver receiver)
{
if (receiver == null)
{
return;
}
var clients = Clients.Where(x => x.Value == receiver);
if (clients.Any())
{
foreach (var key in clients.Select(x => x.Key))
{
IClientEntity client;
if (Clients.TryRemove(key, out client))
{
await client.CloseAsync();
}
}
}
else
{
await receiver.CloseAsync();
}
return;
}
public async Task GetMessages(string queueName, long count, int getQuantity)
{
count = count > getQuantity ? getQuantity : count;
CreateMessageReceiver(queueName, 250);
await _batchMessageStrategy.Execute(queueName, count, _batchSize,
async (qty) => await ProcessMessagesInTransaction(queueName, qty), async (message) => message);
await _messageReceiver.CloseAsync();
}
protected async Task CloseReceiverAsync()
{
if (!_receiver.IsClosedOrClosing)
{
await _receiver.CloseAsync().ConfigureAwait(false);
_logger.LogInformation(
LogEventIds.ListenerFinished,
$"Stopped listening for {_name} on {_receiver.ServiceBusConnection.Endpoint}/{_endpointHandlingConfig.EntityPath}",
_receiver.ServiceBusConnection.Endpoint, _name);
}
}
public async Task StopAsync()
{
if (!receiver.IsClosedOrClosing)
{
await receiver.CloseAsync().ConfigureAwait(false);
}
if (isTopic)
{
await manager.DeleteSubscribtionIfExisted(subscriptionId).ConfigureAwait(false);
}
}
public async Task RunAsync()
{
_logger.LogInformation($"BEGIN - {nameof(ServiceBusReceiverApp)} starting");
_receiver.ReceiveMessages();
Console.ReadKey();
await _receiver.CloseAsync();
_logger.LogInformation($"END - {nameof(ServiceBusReceiverApp)} finished");
}
static async Task ReceiveAndProcess(ILogger log, GridEvent[] ge)
{
log.LogInformation($"TopicName: {ge[0].Data["topicName"]} : SubscriptionName: {ge[0].Data["subscriptionName"]}");
// Get entity path, at this point you would in case you want to use Event Grid to monitor and react to deadletter messages likely also look for that.
string EntityPath = $"{ge[0].Data["topicName"]}/subscriptions/{ge[0].Data["subscriptionName"]}";// e.g.: topicname/subscriptions/subscriptionname
// Create MessageReceiver
messageReceiver = new MessageReceiver(ServiceBusConnectionString, EntityPath, ReceiveMode.PeekLock, null, numberOfMessages);
// Receive messages
await ReceiveMessagesAsync(numberOfMessages, log);
await messageReceiver.CloseAsync();
}
static async Task MainAsync()
{
//This sample uses the EntityNameHelper.FormatDeadLetterPath method for getting the DLQ path for a given queue name/subscription path. A mesage receiver can then be configured using this DLQ path.
deadLetterReceiver = new MessageReceiver(ServiceBusConnectionString, EntityNameHelper.FormatDeadLetterPath(EntityPath), ReceiveMode.PeekLock);
Console.WriteLine("==========================================================================");
Console.WriteLine("Press any key to exit after processing all the dead letter queue messages.");
Console.WriteLine("==========================================================================");
// Register QueueClient's DLQ MessageHandler
RegisterDeadLetterQueueMessageHandler();
Console.ReadKey();
await deadLetterReceiver.CloseAsync();
}
public async Task TryShutDown()
{
try
{
await Task
.WhenAll(
topicClient.CloseAsync(),
messageReceiver.CloseAsync())
.ConfigureAwait(false);
}
catch (ServiceBusException exception)
{
logger.LogError(
exception,
$"Exception when shutting down connection {connectionStringNumber}: {exception.Message}");
}
}
static async Task ReceiveAndProcess(TraceWriter log)
{
const int numberOfMessages = 10;
messageSender = new MessageSender(ServiceBusConnectionString, TopicName);
messageReceiver = new MessageReceiver(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock, null, numberOfMessages);
// Register QueueClient's MessageHandler and receive messages in a loop
await ReceiveMessagesAsync(numberOfMessages, log);
// Send Messages
//await SendMessagesAsync(numberOfMessages);
await messageSender.CloseAsync();
await messageReceiver.CloseAsync();
}
public async Task <bool> ResubmitDeadLetterMessageAsync(string messageId, string serviceBusQueue, long sequenceNumber)
{
bool IsSuccess = false;
IMessageReceiver messageReceiver = _messageReceiverFactory.Create(serviceBusQueue, ReceiveMode.PeekLock, true);
Message deadLetter = await messageReceiver.PeekBySequenceNumberAsync(sequenceNumber);
if (deadLetter != null)
{
var newMessage = _messageReader.ReadMessage(Encoding.UTF8.GetString(deadLetter.Body));
//Check that the messageId matches the one that we want to re-enqueue
if (newMessage.MessageId.Equals(messageId))
{
try
{
//Attempt to send the message back onto the queue
// never re-queue a message with a duplicate id - it will fail to save to message archive
newMessage.MessageId = Guid.NewGuid().ToString();
await _messageSender.SendMessage(newMessage);
}
catch (Exception ex)
{
_log.LogError(ex, "ResubmitDeadLetterMessageAsync Exception");
throw new ServiceBusReaderException("ResubmitDeadLetterMessageAsync", ex);
}
finally
{
//Delete message after resubmitting
var msg = await messageReceiver.ReceiveAsync();
await messageReceiver.CompleteAsync(msg.SystemProperties.LockToken);
IsSuccess = true;
}
}
}
await messageReceiver.CloseAsync();
return(IsSuccess);
}
public async Task ReceiveMessages()
{
try
{
messageReceiver =
new MessageReceiver(ServiceBusConnectionString, QueueName);
while (messageReceiver.OwnsConnection)
{
Message message = await messageReceiver.ReceiveAsync();
Console.WriteLine($"Received message: {message.Body}");
await messageReceiver.CloseAsync();
}
}
catch (Exception exception)
{
Console.WriteLine($"{DateTime.Now} > Exception: {exception.Message}");
}
await Task.Delay(10);
}
static async Task MainAsync()
{
const int numberOfMessages = 10;
messageSender = new MessageSender(ServiceBusConnectionString, QueueName);
messageReceiver = new MessageReceiver(ServiceBusConnectionString, QueueName, ReceiveMode.PeekLock);
// Send Messages
await SendMessagesAsync(numberOfMessages);
// Receive Messages
await ReceiveMessagesAsync(numberOfMessages);
Console.WriteLine("=========================================================");
Console.WriteLine("Completed Receiving all messages... Press any key to exit");
Console.WriteLine("=========================================================");
Console.ReadKey();
await messageSender.CloseAsync();
await messageReceiver.CloseAsync();
}
public void Close()
{
Logger.Value.Warn("Closing the MessageReceiver connection");
_messageReceiver.CloseAsync().GetAwaiter().GetResult();
Logger.Value.Warn("MessageReceiver connection stopped");
}
/// <summary>
/// Closes the connection.
/// </summary>
private void Close()
{
_primaryMessageReceiver?.CloseAsync().ConfigureAwait(false).GetAwaiter().GetResult();
_secondaryMessageReceiver?.CloseAsync().ConfigureAwait(false).GetAwaiter().GetResult();
}
internal void StartMessageBatchReceiver(CancellationToken cancellationToken)
{
SessionClient sessionClient = null;
IMessageReceiver receiver = null;
if (_isSessionsEnabled)
{
sessionClient = _messagingProvider.CreateSessionClient(_entityPath, _serviceBusAccount.ConnectionString);
}
else
{
receiver = Receiver;
}
Task.Run(async() =>
{
while (true)
{
try
{
if (!_started || cancellationToken.IsCancellationRequested)
{
return;
}
if (_isSessionsEnabled)
{
try
{
receiver = await sessionClient.AcceptMessageSessionAsync();
}
catch (ServiceBusTimeoutException)
{
// it's expected if the entity is empty, try next time
continue;
}
}
IList <Message> messages = await receiver.ReceiveAsync(_serviceBusOptions.BatchOptions.MaxMessageCount, _serviceBusOptions.BatchOptions.OperationTimeout);
if (messages != null)
{
Message[] messagesArray = messages.ToArray();
ServiceBusTriggerInput input = ServiceBusTriggerInput.CreateBatch(messagesArray);
input.MessageReceiver = receiver;
FunctionResult result = await _triggerExecutor.TryExecuteAsync(input.GetTriggerFunctionData(), cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
return;
}
// Complete batch of messages only if the execution was successful
if (_serviceBusOptions.BatchOptions.AutoComplete && _started)
{
if (result.Succeeded)
{
await receiver.CompleteAsync(messagesArray.Select(x => x.SystemProperties.LockToken));
}
else
{
// Delivery count is not incremented if
// Session is accepted, the messages within the session are not completed (even if they are locked), and the session is closed
// https://docs.microsoft.com/en-us/azure/service-bus-messaging/message-sessions#impact-of-delivery-count
if (_isSessionsEnabled)
{
List <Task> abandonTasks = new List <Task>();
foreach (var lockTocken in messagesArray.Select(x => x.SystemProperties.LockToken))
{
abandonTasks.Add(receiver.AbandonAsync(lockTocken));
}
await Task.WhenAll(abandonTasks);
}
}
}
// Close the session and release the session lock
if (_isSessionsEnabled)
{
await receiver.CloseAsync();
}
}
}
catch (ObjectDisposedException)
{
// Ignore as we are stopping the host
}
catch (Exception ex)
{
// Log another exception
_logger.LogError($"An unhandled exception occurred in the message batch receive loop: {ex.ToString()}");
}
}
}, cancellationToken);
}
public void Stop()
{
_receiverTokenSource?.Cancel();
_receiverTask?.Wait(ReceiverTimeoutOnExit);
_receiver?.CloseAsync().Wait();
}
public void Close()
{
_messageReceiver.CloseAsync().Wait();
}
public Task CloseAsync()
{
return(_receiver.CloseAsync());
}
internal void StartMessageBatchReceiver(CancellationToken cancellationToken)
{
SessionClient sessionClient = null;
IMessageReceiver receiver = null;
if (_isSessionsEnabled)
{
sessionClient = _sessionClient.Value;
}
else
{
receiver = Receiver;
}
Task.Run(async() =>
{
while (true)
{
try
{
if (!_started || cancellationToken.IsCancellationRequested)
{
_logger.LogInformation("Message processing has been stopped or cancelled");
return;
}
if (_isSessionsEnabled && (receiver == null || receiver.IsClosedOrClosing))
{
try
{
receiver = await sessionClient.AcceptMessageSessionAsync();
receiver.PrefetchCount = _serviceBusOptions.PrefetchCount;
}
catch (ServiceBusTimeoutException)
{
// it's expected if the entity is empty, try next time
continue;
}
}
IList <Message> messages = await receiver.ReceiveAsync(_serviceBusOptions.BatchOptions.MaxMessageCount, _serviceBusOptions.BatchOptions.OperationTimeout);
if (messages != null)
{
Message[] messagesArray = messages.ToArray();
ServiceBusTriggerInput input = ServiceBusTriggerInput.CreateBatch(messagesArray);
input.MessageReceiver = receiver;
FunctionResult result = await _triggerExecutor.TryExecuteAsync(input.GetTriggerFunctionData(), cancellationToken);
if (cancellationToken.IsCancellationRequested)
{
return;
}
// Complete batch of messages only if the execution was successful
if (_serviceBusOptions.BatchOptions.AutoComplete && _started)
{
if (result.Succeeded)
{
await receiver.CompleteAsync(messagesArray.Select(x => x.SystemProperties.LockToken));
}
else
{
List <Task> abandonTasks = new List <Task>();
foreach (var lockTocken in messagesArray.Select(x => x.SystemProperties.LockToken))
{
abandonTasks.Add(receiver.AbandonAsync(lockTocken));
}
await Task.WhenAll(abandonTasks);
}
}
}
else
{
// Close the session and release the session lock after draining all messages for the accepted session.
if (_isSessionsEnabled)
{
await receiver.CloseAsync();
}
}
}
catch (ObjectDisposedException)
{
// Ignore as we are stopping the host
}
catch (Exception ex)
{
// Log another exception
_logger.LogError($"An unhandled exception occurred in the message batch receive loop", ex);
if (_isSessionsEnabled && receiver != null)
{
// Attempt to close the session and release session lock to accept a new session on the next loop iteration
try
{
await receiver.CloseAsync();
}
catch
{
// Best effort
receiver = null;
}
}
}
}
}, cancellationToken);
}
public void Close()
{
s_logger.LogWarning("Closing the MessageReceiver connection");
_messageReceiver.CloseAsync().GetAwaiter().GetResult();
s_logger.LogWarning("MessageReceiver connection stopped");
}
static async Task MainListenMessageAsync(string[] args)
{
await ListenMessageAsync();
await _queueReceiver.CloseAsync();
}
