Struct RedisTransaction 

pub struct RedisTransaction { /* private fields */ }

An owned Redis transaction, opened by transaction on a RedisPublisher.

A private XADD buffer, flushed on commit through the same MULTI / EXEC path as the handle-level kind (so the whole batch becomes visible atomically, in publish order) and discarded on abort.

What sets it apart from the handle-level TransactionalPublisher buffer is ownership, not the commit: any number of these can be open on one handle at a time, and the handle keeps publishing directly while they are. The buffers are independent, so settling one never touches another; only the flush itself takes a pooled connection.

Examples

use ruststream::{Broker, OutgoingMessage, OwnedTransactions, Transaction};
use ruststream_fred::RedisBroker;

let connected = RedisBroker::standalone("redis://localhost:6379").connect().await?;
let publisher = connected.publisher();

let mut orders = publisher.transaction().await?;
let mut audit = publisher.transaction().await?; // concurrent with `orders`
orders.publish(OutgoingMessage::new("orders", b"{}".as_slice())).await?;
audit.publish(OutgoingMessage::new("audit", b"{}".as_slice())).await?;
orders.commit().await?;
audit.commit().await?;

Trait Implementations

impl Debug for RedisTransaction

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

Formats the value using the given formatter.

impl Drop for RedisTransaction

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 RedisTransaction

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

Buffers the XADD locally; nothing reaches the server before commit.

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

Flushes the buffer as one MULTI / EXEC block, in publish order.

Errors

Returns RedisError::ShutDown when the connection this transaction was opened from is gone, or RedisError::Publish when the block is rejected. 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.

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

Discards the buffer. Nothing was sent to the server, so this cannot fail.

type Error = RedisError

The error type returned by transaction operations.