Struct RedisListPublish 

pub struct RedisListPublish { /* private fields */ }

The declaration half of the list publisher: envelope codec and key TTL, no connection.

Constructible anywhere, it pairs into a RedisListPublisher against a ConnectedRedisBroker.

Examples

use std::time::Duration;

use ruststream::codec::JsonCodec;
use ruststream_fred::RedisListPublish;
use ruststream_fred::list::prelude::*;
use serde::{Deserialize, Serialize};

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

#[derive(Serialize, Outgoing)]
#[outgoing(name = "jobs.done")]
struct Done {
    id: u64,
}

#[subscriber(RedisList::new("jobs").reliable(), reply)]
async fn run_job(job: &Job) -> Done {
    Done { id: job.id }
}

#[ruststream::app]
fn app() -> impl App {
    RustStream::new(AppInfo::new("jobs", "0.1.0")).with_broker(
        RedisBroker::standalone("redis://localhost:6379"),
        |b| {
            // A readable JSON frame, and a `jobs.done` nobody drains expires five minutes
            // after the last push.
            b.include(run_job).out_reply(
                RedisListPublish::new()
                    .codec(JsonCodec)
                    .ttl(Duration::from_secs(300)),
            );
        },
    )
}

Implementations

impl RedisListPublish

pub fn new() -> Self

A policy with the default binary framing and no key TTL. Equivalent to Self::default.

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.

pub const fn ttl(self, ttl: Duration) -> Self

Sets a time-to-live on the list key, refreshed (PEXPIRE) on every publish, so an idle queue auto-expires. Off by default: without it the list lives until drained or deleted.

This is a per-key TTL on the whole list, not per-entry: Redis lists have no per-element expiry, only the key can expire. Each publish pushes the entry and re-arms the key’s TTL in one pipeline, so an actively used queue never expires and only an idle one does. A sub- millisecond ttl is clamped up to 1ms, since PEXPIRE 0 would delete the key outright.

Trait Implementations

impl Clone for RedisListPublish

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 RedisListPublish

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

Formats the value using the given formatter.

impl Default for RedisListPublish

fn default() -> Self

Returns the “default value” for a type.

impl PublishPolicy<ConnectedRedisBroker> for RedisListPublish

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

The list key the policy pushes onto, the expiry it re-arms there on every push, and how headers are framed beside the payload.

type Live = RedisListPublisher

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.