Struct RoundMessage 

pub struct RoundMessage<F: Form> { /* private fields */ }

A delivery of a .pipeline() subscription.

It reads as the form’s own delivery does, and settles into the window instead of on the connection: ack commits what the handler queued together with the delivery’s settle, and every other outcome drops it. A delivery dropped unsettled drops its segment and stays with the broker.

Examples

use ruststream_fred::stream::prelude::*;

#[subscriber(RedisStream::new("orders").group("workers"))]
async fn work(order: &Order) -> HandlerOutcome {
    println!("order {}", order.id);
    HandlerOutcome::ack()
}

fn app() -> RustStream {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        RedisBroker::standalone("redis://localhost:6379"),
        |b| {
            // The subscription yields this type; the handler reads it as any delivery.
            b.include(work.pipeline());
        },
    )
}

Trait Implementations

impl<F: Form> BuildBatchContext<RoundMessage<F>> for PipelineContext

A batch of a .pipeline() subscription is one segment: its context hands the batch body the round every delivery of the batch shares.

fn build(first: &RoundMessage<F>) -> Self

Builds the context value by reading subscription-scoped fields out of the batch’s first delivery.

impl<F: Form> BuildContext<RoundMessage<F>> for PipelineContext

fn build(msg: &RoundMessage<F>) -> Self

Builds the context value by reading fields out of msg.

impl<F: Form> BuildContext<RoundMessage<F>> for PoolContext

fn build(msg: &RoundMessage<F>) -> Self

Builds the context value by reading fields out of msg.

impl<F: Form> Debug for RoundMessage<F>

where F::Message: Debug,

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

Formats the value using the given formatter.

impl<F: Form> Drop for RoundMessage<F>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<F: Form> IncomingMessage for RoundMessage<F>

fn payload(&self) -> &[u8]

Also enters the round: the payload is what the runtime reads to decode the input, and it reads the headers only when something asks for them.

fn headers(&self) -> &HeaderMap

Also enters the round, for a handler that reads the headers alone.

fn partition_key(&self) -> Option<&[u8]>

Returns the routing key the broker partitioned this message by, or None when the message carries no key.

fn redelivery_count(&self) -> Option<u64>

How many times the broker has delivered this message, counting this delivery. None where the transport counts nothing.

fn supports_nack_after(&self) -> bool

Reports whether this transport can honor nack_after natively.

async fn ack(self) -> Result<(), AckError>

Acknowledges successful processing. Consumes the message handle.

async fn nack(self, requeue: bool) -> Result<(), AckError>

Negatively acknowledges the message. When requeue is true the broker should redeliver according to its own retry policy; when false it should drop or dead-letter the message.

async fn nack_after(self, delay: Duration) -> Result<(), AckError>

Negatively acknowledges the message, asking the broker to redeliver it no sooner than delay from now.

impl<F: Form> Partitioned for RoundMessage<F>

where F::Message: Partitioned,

fn partition_key(&self) -> Option<&[u8]>

Returns the partition key for this item, or None if the broker should pick a partition.