Struct BulkOperationHandler 

pub struct BulkOperationHandler { /* private fields */ }

High-level handler for bulk operations on Azure Service Bus messages.

The BulkOperationHandler provides a simplified interface for performing bulk operations like deleting multiple messages, sending messages to dead letter queues, and resending messages from dead letter queues. It orchestrates the underlying bulk deletion and processing logic.

Features

• Bulk Delete - Efficiently delete multiple messages from queues
• Dead Letter Operations - Move messages to/from dead letter queues
• Batch Processing - Configurable batch sizes for optimal performance
• Error Handling - Comprehensive error reporting with operation results
• Cancellation Support - Graceful cancellation of long-running operations

Examples

use quetty_server::bulk_operations::{BulkOperationHandler, BatchConfig, MessageIdentifier};
use quetty_server::consumer::Consumer;
use std::sync::Arc;
use tokio::sync::Mutex;

async fn example(consumer: Arc<Mutex<Consumer>>) -> Result<(), Box<dyn std::error::Error>> {
    let config = BatchConfig::default();
    let handler = BulkOperationHandler::new(config);

    let message_ids = vec![
        MessageIdentifier::SequenceNumber(12345),
        MessageIdentifier::SequenceNumber(12346),
    ];

    let result = handler.delete_messages(
        consumer,
        "my-queue".to_string(),
        message_ids,
        100, // max_position
    ).await?;

    println!("Deleted {} messages", result.successful_count);
    Ok(())
}

Implementations

impl BulkOperationHandler

pub fn new(config: BatchConfig) -> Self

Creates a new BulkOperationHandler with the specified configuration.

Arguments

• config - Batch configuration controlling operation behavior

Examples

use quetty_server::bulk_operations::{BulkOperationHandler, BatchConfig};

let config = BatchConfig {
    batch_size: 50,
    timeout: std::time::Duration::from_secs(30),
    ..Default::default()
};
let handler = BulkOperationHandler::new(config);

pub async fn delete_messages( &self, consumer: Arc<Mutex<Consumer>>, queue_name: String, targets: Vec<MessageIdentifier>, max_position: usize, ) -> Result<BulkOperationResult, Box<dyn Error + Send + Sync>>

Executes a bulk delete operation on the specified messages.

This method deletes multiple messages from a Service Bus queue efficiently by processing them in batches. It provides comprehensive error reporting and handles partial failures gracefully.

Arguments

• consumer - Service Bus consumer for message operations
• queue_name - Name of the queue containing the messages
• targets - List of message identifiers to delete
• max_position - Maximum position limit for message processing

Returns

BulkOperationResult containing the count of successful and failed operations

Errors

Returns an error if:

• The consumer is unavailable or disposed
• Service Bus operations fail
• The operation is cancelled
• Invalid message identifiers are provided

Examples

use quetty_server::bulk_operations::{BulkOperationHandler, MessageIdentifier};
use quetty_server::consumer::Consumer;
use std::sync::Arc;
use tokio::sync::Mutex;

async fn delete_example(
    handler: &BulkOperationHandler,
    consumer: Arc<Mutex<Consumer>>
) -> Result<(), Box<dyn std::error::Error>> {
    let messages_to_delete = vec![
        MessageIdentifier::SequenceNumber(100),
        MessageIdentifier::SequenceNumber(101),
        MessageIdentifier::SequenceNumber(102),
    ];

    let result = handler.delete_messages(
        consumer,
        "orders-queue".to_string(),
        messages_to_delete,
        1000,
    ).await?;

    println!("Successfully deleted: {}", result.successful_count);
    println!("Failed to delete: {}", result.failed_count);

    Ok(())
}

Trait Implementations

impl Default for BulkOperationHandler

fn default() -> Self

Creates a BulkOperationHandler with default configuration.

Uses the default BatchConfig settings for batch size, timeouts, and other operation parameters.

Examples

use quetty_server::bulk_operations::BulkOperationHandler;

let handler = BulkOperationHandler::default();