pub struct Consumer { /* private fields */ }Expand description
A wrapper around Azure Service Bus receiver for consuming messages from queues.
The Consumer provides a high-level interface for receiving, processing, and managing messages from Azure Service Bus queues. It supports both peek operations (non-destructive) and receive operations (which lock messages for processing).
§Thread Safety
The Consumer is thread-safe and can be shared across async tasks. The underlying receiver is protected by a mutex to ensure safe concurrent access.
§Examples
use quetty_server::consumer::Consumer;
use azservicebus::{ServiceBusReceiver, ServiceBusReceiverOptions};
async fn example(receiver: ServiceBusReceiver) {
let mut consumer = Consumer::new(receiver);
// Peek at messages without consuming them
let messages = consumer.peek_messages(10, None).await?;
// Receive messages for processing
let received = consumer.receive_messages_with_timeout(5, std::time::Duration::from_secs(10)).await?;
// Process and complete messages
for message in &received {
consumer.complete_message(message).await?;
}
}Implementations§
Source§impl Consumer
impl Consumer
Sourcepub fn new(receiver: ServiceBusReceiver) -> Self
pub fn new(receiver: ServiceBusReceiver) -> Self
Creates a new Consumer wrapping the provided Service Bus receiver.
§Arguments
receiver- The Azure Service Bus receiver to wrap
Sourcepub async fn peek_messages(
&mut self,
max_count: u32,
from_sequence_number: Option<i64>,
) -> Result<Vec<MessageModel>, Box<dyn Error>>
pub async fn peek_messages( &mut self, max_count: u32, from_sequence_number: Option<i64>, ) -> Result<Vec<MessageModel>, Box<dyn Error>>
Peeks at messages in the queue without consuming them.
This operation allows you to inspect messages without locking them or affecting their delivery count. Useful for browsing queue contents.
§Arguments
max_count- Maximum number of messages to peek atfrom_sequence_number- Optional starting sequence number
§Returns
Vector of MessageModel instances representing the peeked messages
§Errors
Returns an error if the receiver has been disposed or if the Service Bus operation fails
Sourcepub async fn receive_messages_with_timeout(
&mut self,
max_count: u32,
timeout: Duration,
) -> Result<Vec<ServiceBusReceivedMessage>, Box<dyn Error>>
pub async fn receive_messages_with_timeout( &mut self, max_count: u32, timeout: Duration, ) -> Result<Vec<ServiceBusReceivedMessage>, Box<dyn Error>>
Receives messages from the queue with a timeout.
This operation locks the received messages for processing. The messages must be completed, abandoned, or dead-lettered to release the lock.
§Arguments
max_count- Maximum number of messages to receivetimeout- Maximum time to wait for messages
§Returns
Vector of received messages that are locked for processing. Returns an empty vector if the timeout expires before messages are available.
§Errors
Returns an error if the receiver has been disposed or if the Service Bus operation fails
Sourcepub async fn abandon_message(
&mut self,
message: &ServiceBusReceivedMessage,
) -> Result<(), Box<dyn Error>>
pub async fn abandon_message( &mut self, message: &ServiceBusReceivedMessage, ) -> Result<(), Box<dyn Error>>
Sourcepub async fn dead_letter_message(
&mut self,
message: &ServiceBusReceivedMessage,
reason: Option<String>,
error_description: Option<String>,
) -> Result<(), Box<dyn Error>>
pub async fn dead_letter_message( &mut self, message: &ServiceBusReceivedMessage, reason: Option<String>, error_description: Option<String>, ) -> Result<(), Box<dyn Error>>
Moves a message to the dead letter queue.
Dead lettered messages are permanently removed from the main queue and can be inspected in the dead letter queue for debugging.
§Arguments
message- The message to dead letterreason- Optional reason for dead letteringerror_description- Optional error description
§Errors
Returns an error if the receiver has been disposed or if the Service Bus operation fails
Sourcepub async fn complete_message(
&mut self,
message: &ServiceBusReceivedMessage,
) -> Result<(), Box<dyn Error>>
pub async fn complete_message( &mut self, message: &ServiceBusReceivedMessage, ) -> Result<(), Box<dyn Error>>
Sourcepub async fn complete_messages(
&mut self,
messages: &[ServiceBusReceivedMessage],
) -> Result<(), Box<dyn Error>>
pub async fn complete_messages( &mut self, messages: &[ServiceBusReceivedMessage], ) -> Result<(), Box<dyn Error>>
Completes multiple messages in a batch for better performance.
Attempts to complete all provided messages, logging results for each. If any message fails to complete, the operation continues with remaining messages and returns an error indicating the failure count.
§Arguments
messages- Slice of messages to complete
§Returns
Ok(()) if all messages were completed successfully,
Err if any messages failed to complete
§Errors
Returns an error if the receiver has been disposed or if any message completion fails
Sourcepub async fn abandon_messages(
&mut self,
messages: &[ServiceBusReceivedMessage],
) -> Result<(), Box<dyn Error>>
pub async fn abandon_messages( &mut self, messages: &[ServiceBusReceivedMessage], ) -> Result<(), Box<dyn Error>>
Sourcepub async fn renew_message_lock(
&mut self,
message: &mut ServiceBusReceivedMessage,
) -> Result<(), Box<dyn Error>>
pub async fn renew_message_lock( &mut self, message: &mut ServiceBusReceivedMessage, ) -> Result<(), Box<dyn Error>>
Renews the lock on a received message to extend processing time.
This prevents the message from becoming available for redelivery while it’s still being processed.
§Arguments
message- The message whose lock should be renewed
§Errors
Returns an error if the receiver has been disposed or if the lock renewal fails
Sourcepub async fn renew_message_locks(
&mut self,
messages: &mut [ServiceBusReceivedMessage],
) -> Result<(), Box<dyn Error>>
pub async fn renew_message_locks( &mut self, messages: &mut [ServiceBusReceivedMessage], ) -> Result<(), Box<dyn Error>>
Renews locks on multiple messages.
Attempts to renew locks for all provided messages, logging results. Continues processing all messages even if some renewals fail.
§Arguments
messages- Mutable slice of messages whose locks should be renewed
§Errors
Returns an error if the receiver has been disposed. Lock renewal failures are logged but do not cause the method to return an error.
Sourcepub async fn dispose(&self) -> Result<(), Box<dyn Error>>
pub async fn dispose(&self) -> Result<(), Box<dyn Error>>
Disposes the underlying Service Bus receiver, releasing all resources.
After disposal, all other operations on this Consumer will fail.
§Errors
Returns an error if the disposal operation fails
Sourcepub async fn receive_deferred_messages(
&mut self,
sequence_numbers: &[i64],
) -> Result<Vec<ServiceBusReceivedMessage>, Box<dyn Error + Send + Sync>>
pub async fn receive_deferred_messages( &mut self, sequence_numbers: &[i64], ) -> Result<Vec<ServiceBusReceivedMessage>, Box<dyn Error + Send + Sync>>
Receives deferred messages by their sequence numbers.
This allows operations (delete/complete) on messages that were previously deferred without re-activating them in the main queue first.
§Arguments
sequence_numbers- Array of sequence numbers for the deferred messages
§Returns
Vector of received deferred messages that are locked for processing
§Errors
Returns an error if the receiver has been disposed or if the Service Bus operation fails