Struct RedisPublisher 

pub struct RedisPublisher { /* private fields */ }

The live stream publisher: RedisPublish paired with a connection. Cheap to clone.

Publisher::publish appends the message to the stream named by OutgoingMessage::name with XADD <name> * .... The payload and headers are encoded as entry fields (see crate::RedisStream for the consuming side).

A publisher may outlive the connected broker it came from (it is a handle aliasing the connection), so every operation after shutdown reports RedisError::ShutDown rather than running against a closed pool.

Transactions

Both framework transaction kinds are available on standalone and sentinel topologies, and both commit the same way: the buffer is held client-side while the transaction is open and flushed as one MULTI / EXEC block, in publish order, so subscribers see the whole batch or none of it. They differ only in where that buffer lives.

• Borrowed (TransactionalPublisher): the handle carries one transaction. begin_transaction claims it and starts buffering published messages, commit flushes them, and abort discards them. Clones of a handle share the same open transaction, and a second begin_transaction while one is open is rejected.
• Owned (OwnedTransactions): every transaction call returns a RedisTransaction owning its own buffer, so any number can be open on one handle concurrently and the handle keeps publishing directly meanwhile.

Two Redis properties apply to both kinds. Cluster supports neither, because a MULTI block cannot span hash slots, so opening a transaction there returns RedisError::InvalidOptions. And Redis has no rollback: a command that fails at runtime inside EXEC does not undo the commands before it. For a block of XADDs against stream keys that is practically limited to out-of-memory and wrong-type keys; a command the server refuses to queue discards the whole block.

Trait Implementations

impl Clone for RedisPublisher

fn clone(&self) -> RedisPublisher

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RedisPublisher

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

Formats the value using the given formatter.

impl OwnedTransactions for RedisPublisher

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

async fn transaction(&self) -> Result<RedisTransaction, RedisError>

Errors

Returns RedisError::InvalidOptions on a cluster topology, which cannot offer multi-key transactions.

type Transaction = RedisTransaction

The buffer-owning transaction opened by transaction.

impl Publisher for RedisPublisher

type Error = RedisError

The error type returned by publish.

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

Publishes a message to the broker.

impl TransactionalPublisher for RedisPublisher

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

Starts buffering published messages on this handle.

Errors

Returns RedisError::InvalidOptions on a cluster topology, which cannot offer multi-key transactions, or RedisError::TransactionBusy when a transaction is already open on this handle (the open one is left untouched).

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

Flushes the buffered XADDs as one MULTI / EXEC block, in publish order, then clears the transaction.

Errors

Returns RedisError::NoTransaction when no transaction is open on this handle, RedisError::ShutDown when the connection is gone, or RedisError::Publish if the block is rejected. On failure the transaction is already closed: the buffer is lost, and recovery is redelivery of the inputs rather than resubmission of the buffer.

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

Discards the buffered messages.

Errors

Returns RedisError::NoTransaction when no transaction is open on this handle.