Struct RedisPublish 

pub struct RedisPublish;

The declaration half of the stream publisher: pure policy, constructible anywhere.

XADD needs no options beyond the target key, which travels on each message, so the policy is a unit marker. It pairs into a RedisPublisher against a ConnectedRedisBroker, which is what makes “publishing before connect” unrepresentable.

Examples

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

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

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

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

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        RedisBroker::standalone("redis://localhost:6379"),
        |b| {
            // `Publish` is this policy under the stream prelude's name. No connection exists
            // yet; the runtime pairs it with the connected broker at startup.
            b.include(accept).out_reply(Publish);
        },
    )
}

Trait Implementations

impl Clone for RedisPublish

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 RedisPublish

impl Debug for RedisPublish

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

Formats the value using the given formatter.

impl Default for RedisPublish

fn default() -> Self

Returns the “default value” for a type.

impl Eq for RedisPublish

impl PartialEq for RedisPublish

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

Equality operator ==.

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

Inequality operator !=.

impl PublishPolicy<ConnectedRedisBroker> for RedisPublish

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

An XADD carries its headers as entry fields and the policy has no settings of its own, so what the document learns from here is which Redis structure the channel is and which stream key the entries are appended to.

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 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.

impl StructuralPartialEq for RedisPublish