Struct amiquip::Consumer

pub struct Consumer<'a> { /* fields omitted */ }

A message consumer associated with an AMQP queue.

Example

use amiquip::{Consumer, ConsumerMessage, Result};

// Receive (at least) n messages on the consumer, then cancel it.
fn consume_n_messages(consumer: Consumer, n: usize) -> Result<()> {
    for (i, message) in consumer.receiver().iter().enumerate() {
        match message {
            ConsumerMessage::Delivery(delivery) => handle_delivery(delivery),
            ConsumerMessage::ServerClosedChannel(err)
            | ConsumerMessage::ServerClosedConnection(err) => return Err(err)?,
            ConsumerMessage::ClientCancelled
            | ConsumerMessage::ServerCancelled
            | ConsumerMessage::ClientClosedChannel
            | ConsumerMessage::ClientClosedConnection => break,
        }
        if i >= n {
            consumer.cancel()?;
        }
    }
    Ok(())
}

Implementations

impl Consumer<'_>

pub fn consumer_tag(&self) -> &str

The server-assigned consumer tag.

pub fn receiver(&self) -> &Receiver<ConsumerMessage>

The crossbeam_channel::Receiver on which messages will be delivered. Once a consumer message of any variant other than ConsumerMessage has been received, no more messages will be sent and the sending side of the channel (held by the connection’s I/O thread) will be dropped.

Note on Cloning

Crossbeam channels implement Clone. Be careful cloning this receiver, as the sending side (held by the connection’s I/O thread) will be dropped when self is cancelled, which will happen when cancel is called or self is dropped.

pub fn cancel(&self) -> Result<()>

Cancel this consumer.

When the cancellation is acknowledged by the server, the channel returned by receiver will receive a ConsumerMessage::ClientCancelled message. This method does not consume self because this method is inherently racy; the server may be sending us additional messages as we are attempting to cancel.

Calling this method a second or later time will always return Ok; if you care about cancellation errors, you must capture the Err value on the first call.

pub fn ack(&self, delivery: Delivery) -> Result<()>

Calls Delivery::ack on delivery using the channel that contains this consumer. See the note on that method about taking care not to ack deliveries across channels.

pub fn ack_multiple(&self, delivery: Delivery) -> Result<()>

Calls Delivery::ack_multiple on delivery using the channel that contains this consumer. See the note on that method about taking care not to ack deliveries across channels.

pub fn nack(&self, delivery: Delivery, requeue: bool) -> Result<()>

Calls Delivery::nack on delivery using the channel that contains this consumer. See the note on that method about taking care not to nack deliveries across channels.

pub fn nack_multiple(&self, delivery: Delivery, requeue: bool) -> Result<()>

Calls Delivery::nack_multiple on delivery using the channel that contains this consumer. See the note on that method about taking care not to nack deliveries across channels.

pub fn reject(&self, delivery: Delivery, requeue: bool) -> Result<()>

Calls Delivery::reject on delivery using the channel that contains this consumer. See the note on that method about taking care not to reject deliveries across channels.

Trait Implementations

impl Drop for Consumer<'_>

fn drop(&mut self)

Executes the destructor for this type.