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(); }