Struct icee_rabbit_rs::AmqpConsumer

pub struct AmqpConsumer { /* fields omitted */ }

AmqpConsumer holds open channel and consumes all messages from given queue

Does not support to consume from multiple queues, if required use two Consumers with the same callback

use icee_rabbit_rs::{QueueSettings, AmqpConsumer};

let queue = QueueSettings::new("queue".into());
let callback = |_message| { Ok(()) };

let consumer = AmqpConsumer::new(queue, Some(Box::new(callback)));
consumer.consume().await;

Callback is optional and required only for consume method. If message is required directly, use only connect method which returns consumer directly. Consumer is sure to return upon successfull connection, but does not handle reconnect.

use icee_rabbit_rs::{QueueSettings, AmqpConsumer, DeliveryCallback};
use lapin::options::BasicAckOptions;
use async_std::prelude::StreamExt;

let queue = QueueSettings::new("queue".into());

let amqp_consumer = AmqpConsumer::new(queue, None);
loop {
    let mut consumer = amqp_consumer.connect().await;
    while let Some(delivery) = consumer.next().await {
        if let Ok((_channel, delivery)) = delivery {
            // Do whatever you need with message
            delivery.ack(BasicAckOptions::default()).await.expect("ack message");
        }
    }
}

Implementations

impl AmqpConsumer

pub fn new(
    queue: QueueSettings,
    callback: Option<Box<DeliveryCallback>>
) -> Self

Initializes new Consumer

Connection is taken from GlobalContainer, which must be initialized with init function at the start of the program.

pub fn with_prefetch(&mut self, prefetch: u16) -> &mut Self

Sets prefetch count for a consumer

By default is prefetch set to 5

pub async fn consume(&self)

Starts the consumer sending each message into specified callback

In case of disconnect, consumer awaits for reconnect to continue without yielding an error or panicking

If None callback is given to AmqpConsumer, message is only Ack-ed

pub async fn connect(&self) -> Consumer

Returns connected consumer for custom message handling