Struct PipelineContext 

pub struct PipelineContext { /* private fields */ }

The per-delivery context of a .pipeline() subscription: the delivery’s round and the broker’s connection pool.

Only a pipelined subscription’s delivery builds it, which is what makes Ctx<keys::Pipeline> a compile error on a mount site without .pipeline().

Examples

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

#[subscriber(RedisStream::new("orders").group("workers"))]
async fn work(order: &Order, ctx: &mut Context<'_, PipelineContext>) -> HandlerOutcome {
    let key = format!("orders.seen:{}", order.id);
    if ctx.context(keys::Pipeline).incr(key).await.is_err() {
        return HandlerOutcome::retry();
    }
    HandlerOutcome::ack()
}

fn app() -> RustStream {
    RustStream::new(AppInfo::new("orders", "0.1.0")).with_broker(
        RedisBroker::standalone("redis://localhost:6379"),
        |b| {
            b.include(work.pipeline());
        },
    )
}

Implementations

impl PipelineContext

pub const fn pipeline(&self) -> &RedisPipeline

The delivery’s round: what the handler queues its commands into.

pub const fn pool(&self) -> &Pool

The broker’s connection pool, for a command whose answer the handler needs now.

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, or out of the batch itself where it lends its values as one slice.

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 Clone for PipelineContext

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 PipelineContext

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

Formats the value using the given formatter.

impl Field<PipelineContext> for Pipeline

type Value<'a> = &'a RedisPipeline

The value read through this key, borrowed from the source for 'a.

fn get(self, src: &PipelineContext) -> &RedisPipeline

Reads this key’s field out of src.

impl Field<PipelineContext> for FredPool

type Value<'a> = &'a Pool

The value read through this key, borrowed from the source for 'a.

fn get(self, src: &PipelineContext) -> &Pool

Reads this key’s field out of src.

impl<State: Sync> FromContext<PipelineContext, State> for Ctx<FredPool>

Ctx<keys::FredPool> beside Ctx<keys::Pipeline>: the handler’s context is PipelineContext there.

type Rejection = !

The error returned when extraction fails. It is converted into a HandlerOutcome (the reflexive conversion makes HandlerOutcome itself a valid rejection, and Infallible works for an extractor that never fails) and the delivery is settled by that outcome, skipping the handler body.

fn from_context( ctx: &mut Context<'_, PipelineContext, State>, ) -> impl Future<Output = Result<Self, Infallible>> + Send

Resolves the value from the delivery context. The context is borrowed mutably so an extractor may also read broker fields or take scratch a middleware left for it.