Struct RedisTransactionalPublish 

pub struct RedisTransactionalPublish;

The stream publisher’s policy for a mount that publishes in transactions: it pairs into the same RedisPublisher as RedisPublish, and only where the topology can run one.

Redis Cluster cannot run a MULTI / EXEC block across hash slots, so on a cluster this policy refuses to pair and the service fails to start, naming the registration that asked for it. Without the refusal a .transactional() batch reply would fail to open its transaction on every batch and redeliver it without end.

Examples

use ruststream_fred::stream::prelude::*;
use serde::{Deserialize, Serialize};

#[derive(Deserialize, Serialize, Outgoing)]
#[outgoing(name = "orders.priced")]
struct Order {
    id: u64,
}

#[subscriber(RedisStream::new("orders").group("workers"), reply)]
async fn price(orders: &[Order]) -> Result<Vec<Order>, HandlerOutcome> {
    Ok(orders.iter().map(|order| Order { id: order.id }).collect())
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        RedisBroker::standalone("redis://localhost:6379"),
        |b| {
            // `TransactionalPublish` is this policy under the stream prelude's name: one
            // batch's replies land together, as one MULTI / EXEC block.
            b.include(price.batch(nonzero!(32)))
                .out_reply(TransactionalPublish)
                .transactional();
        },
    )
}

Trait Implementations

impl Clone for RedisTransactionalPublish

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for RedisTransactionalPublish

impl Debug for RedisTransactionalPublish

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

Formats the value using the given formatter.

impl Default for RedisTransactionalPublish

fn default() -> Self

Returns the “default value” for a type.

impl Eq for RedisTransactionalPublish

impl PartialEq for RedisTransactionalPublish

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PublishPolicy<ConnectedRedisBroker> for RedisTransactionalPublish

fn pair( self, connected: &ConnectedRedisBroker, ) -> impl Future<Output = Result<Self::Live, PairError>>

Errors

Returns a PairError carrying RedisError::InvalidOptions on a cluster topology.

type Live = RedisPublisher

The live form this policy pairs into: a Publisher for a leaf policy, or the live wiring form for a combinator stack (a typed publisher over a policy pairs into the same typed publisher over the live leaf).

fn channel_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to its channel in the generated AsyncAPI document.

fn operation_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to its send operation in the document.

fn message_bindings(&self, channel: &str) -> Bindings

What a publish through this policy adds to the messages that leave through it.

fn reply_address_location(&self) -> Option<&'static str>

Where a client finds the address of a reply this policy publishes, as a runtime expression.

impl StructuralPartialEq for RedisTransactionalPublish