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::OutgoingMessage;
use ruststream_fred::stream::prelude::*;

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        RedisBroker::standalone("redis://localhost:6379"),
        |b| {
            b.include(handle);
            // Two buffers open at once on one handle; each commits as its own MULTI / EXEC.
            b.after_startup(TransactionalPublish, async move |publisher| {
                let mut orders = publisher.transaction().await?;
                let mut audit = publisher.transaction().await?;
                let seed = OutgoingMessage::new("orders", br#"{"id":0}"#.as_slice());
                orders.publish(seed, None).await?;
                let note = OutgoingMessage::new("audit", br#"{"seeded":1}"#.as_slice());
                audit.publish(note, None).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

type Payload = Take

The same as RedisPublisher’s: a buffered XADD hands the client the same value.

type Options = RedisPublishOptions

The same as RedisPublisher’s: a buffered XADD is the same command, queued, so a staged message takes a partition key the way a direct one does.

fn publish( &mut self, msg: OutgoingMessage<'_, BytesMut>, options: Option<&Self::Options>, ) -> impl Future<Output = 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.

fn abort(self) -> impl Future<Output = 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.

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.