Struct ConfirmsPublisher 

pub struct ConfirmsPublisher { /* private fields */ }

The live publisher that awaits broker confirms for every message.

Outside a transaction each publish resolves only once the broker confirmed the message. Confirms buffer client-side, so this publisher offers both transaction kinds:

• owned (OwnedTransactions, the natural fit): every transaction call opens an independent ConfirmsTransaction that owns its buffer, so any number can be open on one handle and the handle keeps publishing directly meanwhile;
• borrowed (TransactionalPublisher): the handle carries one buffer between begin_transaction and commit, so a second begin while one is open errors.

Either way commit publishes the buffer in order and awaits all confirms, and abort discards it without touching the broker.

Clones share one confirm channel and one handle-level transaction buffer. Like every live publisher it aliases the connection and may outlive it: after shutdown every operation reports AmqpError::Closed.

Trait Implementations

impl Clone for ConfirmsPublisher

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConfirmsPublisher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl OwnedTransactions for ConfirmsPublisher

Owned transactions: every transaction call opens an independent buffer-owning ConfirmsTransaction, so any number can be open concurrently on one handle, next to (and unaffected by) the handle-level borrowed transaction.

fn transaction( &self, ) -> impl Future<Output = Result<Self::Transaction, Self::Error>>

Opens a transaction owned by the returned value.

Errors

Infallible in practice: opening allocates a buffer and never touches the broker, exactly like the borrowed begin_transaction.

type Transaction = ConfirmsTransaction

The buffer-owning transaction opened by transaction.

impl Publisher for ConfirmsPublisher

type Payload = Lend

basic_publish takes the payload as &[u8] and copies it into the frame it sends, so this publisher reads the bytes and keeps nothing.

async fn publish( &self, msg: OutgoingMessage<'_>, options: Option<&Self::Options>, ) -> Result<(), Self::Error>

Publishes msg, awaiting the broker confirm (or buffering inside a transaction).

The AMQP basic properties are options resolved over the policy’s defaults. Inside a transaction they are buffered with the message and resolved at the commit.

Errors

Returns AmqpError::Closed once the broker has shut down and AmqpError::Publish when the channel rejects the frame or the broker returns a negative confirm.

Cancel safety

Not cancel safe outside a transaction: dropping the future may leave the message published but unconfirmed. Inside a transaction buffering is synchronous and dropping the future is harmless.

type Error = AmqpError

The error type returned by publish.

type Options = LapinPublishOptions

The broker’s per-message settings: a QoS, a priority, an ordering key, whatever this transport lets one message differ from the next in.

fn base_headers(&self) -> Option<&HeaderMap>

The headers this publisher contributes to every message it sends, underneath whatever the message itself names.

impl TransactionalPublisher for ConfirmsPublisher

fn begin_transaction(&self) -> impl Future<Output = Result<(), Self::Error>>

Opens the buffering transaction.

Errors

Returns AmqpError::Transaction when a transaction is already open on this handle; the open transaction is left untouched.

async fn commit(&self) -> Result<(), Self::Error>

Publishes the buffered messages in order and awaits every confirm.

Errors

Returns AmqpError::Transaction when no transaction is open, and AmqpError::Publish when any message fails to publish or the broker returns a negative confirm. Messages already flushed stay published: publisher confirms give durability per message, not atomicity across them (use ServerTxPublish for that).

fn abort(&self) -> impl Future<Output = Result<(), Self::Error>>

Discards the buffered messages without publishing anything.

Errors

Returns AmqpError::Transaction when no transaction is open.