Struct ConfirmsTransaction 

pub struct ConfirmsTransaction { /* private fields */ }

An owned confirm-transaction, opened by transaction on a ConfirmsPublisher.

A private publish buffer: publish appends to this value rather than to the publisher, commit flushes the whole buffer on the confirm channel and awaits every acknowledgement, and abort discards it without touching the broker. Both settle by consuming self, so a double commit or a publish after settling is a compile error.

Unlike the handle-level buffer of the borrowed kind, any number of these can be open on one publisher at a time, and the publisher keeps publishing directly while they are.

Examples

use std::error::Error;

use ruststream_lapin::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize)]
struct Order {
    id: u64,
}

// Two transactions open side by side, each settled on its own.
async fn record(
    publisher: &impl OwnedTransactions,
    order: &Order,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    let mut shipment = publisher.owned_transaction().await?;
    let mut audit = publisher.owned_transaction().await?;
    shipment.publish("shipments", order).await?;
    audit.publish("audit", order).await?;
    shipment.commit().await?;
    audit.commit().await?;
    Ok(())
}

#[subscriber("orders")]
async fn ship(order: &Order, Out(publisher): Out<impl OwnedTransactions>) -> HandlerOutcome {
    if record(publisher, order).await.is_err() {
        return HandlerOutcome::retry();
    }
    HandlerOutcome::ack()
}

fn app() -> RustStream {
    let broker = LapinBroker::new("amqp://localhost:5672");
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(broker, |b| {
        b.include(ship)
            .out(DefaultSlot, TransactionalPublish::default())
            .build();
    })
}

Trait Implementations

impl Debug for ConfirmsTransaction

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

Formats the value using the given formatter.

impl Drop for ConfirmsTransaction

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Transaction for ConfirmsTransaction

type Payload = Take

A buffered message is kept until the commit, so the transaction takes the buffer the framework wrote instead of copying out of one it may only read.

type Options = LapinPublishOptions

The publisher’s own settings: a buffered message becomes an ordinary publish at the commit, so it honours exactly what one outside the transaction does.

fn publish( &mut self, msg: OutgoingFor<'_, Take>, options: Option<&Self::Options>, ) -> impl Future<Output = Result<(), Self::Error>>

Buffers msg and the per-message settings its call site adjusted; nothing reaches the broker before commit.

Errors

Infallible in practice: buffering is local to this value, and a closed connection or a rejected frame surfaces at the commit, which is the visibility point.

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

Publishes the buffered messages in order and awaits every confirm.

Errors

Returns AmqpError::Closed once the broker has shut down, and AmqpError::Publish when a message fails to publish or the broker returns a negative confirm. A failed commit has still consumed the transaction and its buffer is lost: redelivery of the inputs, not resubmission of the buffer, is the recovery path. Messages already flushed stay published - publisher confirms give durability per message, not atomicity across them (use ServerTxPublish for that).

Cancel safety

Not cancel safe: dropping the future mid-flush leaves an unknown prefix of the buffer published.

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

Discards the buffered messages without touching the broker.

Errors

Never fails: nothing was staged on the broker.

type Error = AmqpError

The error type returned by transaction operations.

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

The headers this transaction contributes to every message published through the publish builder, underneath whatever the call site names.