Struct RedisDefaultPublish 

pub struct RedisDefaultPublish;

The broker’s default policy, what a registration publishes through when its mount site names none: a reply, a retry copy, a dead-letter move.

It writes each name the way this service reads it. A name a RedisList subscription reads, or dead-letters to, is LPUSHed in that subscription’s framing; a name a RedisPubSub subscription reads or dead-letters to is published on in its mode and framing; any other name, a stream key included, is XADDed. So a retry copy and a dead-letter move leave through the publish of the form the delivery came from, with nothing named at the mount site.

The route is recorded when a subscription opens, so a name this service does not subscribe to is a stream. A pattern subscription records nothing: its mount site names both the destination and the policy of its copies.

Examples

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

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

#[derive(Deserialize, Serialize, Outgoing)]
#[outgoing(name = "jobs")]
struct Job {
    order: u64,
}

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

#[subscriber(RedisList::new("jobs").reliable())]
async fn work(job: &Job) -> HandlerOutcome {
    tracing::info!(job.order, "job");
    HandlerOutcome::ack()
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        RedisBroker::standalone("redis://localhost:6379"),
        |b| {
            // The reply names no policy, so it leaves through the default one: `jobs` is
            // read as a list here, so the reply is an `LPUSH`.
            b.include(plan);
            b.include(work);
        },
    )
}

Trait Implementations

impl Clone for RedisDefaultPublish

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 RedisDefaultPublish

impl Debug for RedisDefaultPublish

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

Formats the value using the given formatter.

impl Default for RedisDefaultPublish

fn default() -> Self

Returns the “default value” for a type.

impl Eq for RedisDefaultPublish

impl PartialEq for RedisDefaultPublish

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

Equality operator ==.

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

Inequality operator !=.

impl PublishPolicy<ConnectedRedisBroker> for RedisDefaultPublish

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

Described as the stream publish, the family of a name no subscription of the service reads; the document is built before any subscription opens, so a name that turns out to be read as a list or a channel is described as a stream.

type Live = RedisDefaultPublisher

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 RedisDefaultPublish