Struct RoundRobin 

pub struct RoundRobin { /* private fields */ }

A PublishTransform distributing records round-robin across the first count partitions.

Each record is pinned to an incrementing counter modulo count, so the publisher targets partitions 0..count in a cycle, one message each - the evenest possible spread for long, near-constant-cost messages. A record that already names a partition or carries a record key is left alone: keys exist for ordering, and overriding either would silently break the caller’s placement.

The cycle writes the same per-record setting the builder’s partition step writes, so it mounts only over a publisher whose Publisher::Options are KafkaOptions. On an Out slot that setting arrives carrying whatever the call site chose, and the cycle steps aside for it; a reply has no call site, so there the cycle always places.

The count is explicit on purpose (cheap and predictable); it must match the destination topic’s partition count, or the tail partitions simply receive nothing (a smaller count) or publishes fail (a larger one).

Examples

The transform is a step of the mount site’s chain, right after the publish policy:

use ruststream_rdkafka::prelude::*;

#[subscriber("orders", reply)]
async fn plan(order: &Order) -> WorkItem {
    WorkItem { order_id: order.id }
}

fn app() -> RustStream {
    RustStream::new(AppInfo::new("planner", "0.1.0"))
        .with_broker(KafkaBroker::new(["localhost:9092"]), |b| {
            b.include(plan)
                .out_reply(Publish::default())
                .transform(RoundRobin::partitions(8));
        })
}

Implementations

impl RoundRobin

pub fn partitions(count: i32) -> Self

A round-robin cycle over partitions 0..count.

Panics

Panics when count is zero: a cycle over no partitions cannot place anything.

Trait Implementations

impl Debug for RoundRobin

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

Formats the value using the given formatter.

impl<K: ContextKind> PublishTransform<K, KafkaOptions> for RoundRobin

type Destination = Reads

What this transform does to the destination: Reads or Names.

fn apply( &self, out: &mut Outgoing<'_>, options: &mut Option<KafkaOptions>, _cx: &K::View<'_>, )

Transforms out in place before it is sent, reading the position’s view through cx and resolving the broker’s per-message settings through options.