Struct RedisPubSubPublish 

pub struct RedisPubSubPublish { /* private fields */ }

The declaration half of the Pub/Sub publisher: delivery mode and envelope codec, no connection.

Constructible anywhere (in a router definition, in configuration), it pairs into a RedisPubSubPublisher against a ConnectedRedisBroker. The publish mode must match how subscribers subscribed: a sharded publish only reaches sharded subscribers.

Examples

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

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

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

#[subscriber(RedisStream::new("orders").group("workers"), reply)]
async fn announce(order: &Order) -> Placed {
    Placed { id: order.id }
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        RedisBroker::cluster(["10.0.0.1:6379"]),
        |b| {
            // Read from a durable stream, broadcast to whoever is listening with `SPUBLISH`.
            b.include(announce)
                .out_reply(RedisPubSubPublish::new().mode(PubSubMode::Sharded));
        },
    )
}

Implementations

impl RedisPubSubPublish

pub fn new() -> Self

A classic-mode policy with the default binary framing. Equivalent to Self::default.

pub const fn mode(self, mode: PubSubMode) -> Self

Sets the publish mode. Defaults to PubSubMode::Classic.

pub fn codec(self, codec: impl Codec + 'static) -> Self

Serializes the header/payload envelope with codec (must match the subscriber), which makes the wire value readable while the data is text. Without it the default binary framing is used. Either way a payload that is not text is published byte for byte.

Trait Implementations

impl Clone for RedisPubSubPublish

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RedisPubSubPublish

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

Formats the value using the given formatter.

impl Default for RedisPubSubPublish

fn default() -> Self

Returns the “default value” for a type.

impl PublishPolicy<ConnectedRedisBroker> for RedisPubSubPublish

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

The channel a PUBLISH goes out on, the delivery mode it goes out in, and how headers are framed beside the payload.

type Live = RedisPubSubPublisher

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 pair( self, connected: &ConnectedRedisBroker, ) -> impl Future<Output = Result<Self::Live, PairError>>

Pairs the policy with a connected broker, producing the live publisher.

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.