Struct KafkaPartitions 

pub struct KafkaPartitions { /* private fields */ }

A subscription that takes exactly the partitions it names, without joining a consumer group and without rebalancing.

That fits a reader pinned to a partition, an inspection or replay tool, and a one-consumer-per-partition deployment. A group stays optional and changes only how offsets are handled: with one named the consumer commits into the group without joining it, and without one commits are off, so the start offset has to be explicit.

This form reads a subset of a topic, and the partitioner places a published record wherever the key sends it, so no publish addresses it: a registration that retries names the destination itself with .out_retry(policy).to("orders.retry"). Reading the whole topic is KafkaTopic, which addresses its own copies.

Examples

An inspection reader pinned to partition 0, with no group side effects:

use ruststream_rdkafka::context::keys::Offset;
use ruststream_rdkafka::prelude::*;

#[subscriber(KafkaPartitions::new("orders", [0]).start(StartOffset::Earliest))]
async fn inspect(order: &Order, Ctx(offset): Ctx<Offset>) -> HandlerOutcome {
    tracing::info!(order.id, %offset, "read from partition 0");
    HandlerOutcome::ack()
}

fn app() -> RustStream {
    RustStream::new(AppInfo::new("inspector", "0.1.0"))
        .with_broker(KafkaBroker::new(["localhost:9092"]), |b| {
            b.include(inspect);
        })
}

Implementations

impl KafkaPartitions

pub fn new( topic: impl Into<String>, partitions: impl IntoIterator<Item = i32>, ) -> Self

Describes a reader over exactly partitions of topic.

pub fn group(self, group: impl Into<String>) -> Self

The consumer group whose committed offsets this reader uses, overriding KafkaBroker::default_group. The reader commits into the group without ever joining it.

pub fn start(self, start: StartOffset) -> Self

Where the reader starts (see StartOffset). Without a group, StartOffset::Committed has nothing to resume from and is a startup error.

pub fn commit(self, commit: Commit) -> Self

How processed deliveries are committed (see Commit). Commit::Transactional is a startup error here: an exactly-once pipeline commits through the consumer-group protocol this form does not take part in.

pub fn lane_key(self, lane_key: LaneKey) -> Self

What drives keyed worker lanes for this reader (see LaneKey). Under the default each assigned partition gets a lane of its own.

pub fn config(self, key: impl Into<String>, value: impl Into<String>) -> Self

Raw librdkafka consumer property passthrough, applied last (it wins over the typed options and the broker-wide config).

A property the subscription’s Commit mode owns is the exception; see KafkaTopic::config.

pub fn topic(&self) -> &str

The topic these partitions belong to, which is also the handler metadata name.

pub fn partitions(&self) -> &[i32]

The partitions this reader takes.

Trait Implementations

impl Clone for KafkaPartitions

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 KafkaPartitions

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

Formats the value using the given formatter.

impl IntoSource for KafkaPartitions

type Source = KafkaPartitions

The source the constructor stores.

fn into_source(self) -> Self

Builds the source.

impl SubscriptionSource<ConnectedKafkaBroker> for KafkaPartitions

type Subscriber = KafkaSubscriber

The subscriber type this source opens.

type Copies = NamedCopies

Who publishes the copies this subscription’s retries are made of, and who names where they go: AddressedCopies, NamedCopies or BrokerMoves.

fn name(&self) -> &str

The name (subject / channel) this subscription binds to.

async fn subscribe( self, connected: &ConnectedKafkaBroker, ) -> Result<Self::Subscriber, KafkaError>

Opens the subscription against the connected broker. Called once at startup.

fn channel_bindings(&self) -> Bindings

What this subscription adds to its channel in the generated AsyncAPI document.

fn operation_bindings(&self) -> Bindings

What this subscription adds to its receive operation in the document.

fn declare_retry(self, declaration: &RetryDeclaration) -> Self

where Self: Sized,

Takes the registration’s retry declaration into the descriptor, before the subscription opens.

fn declare_retry_on( &self, connected: &C, declaration: &RetryDeclaration, ) -> Result<(), DeclareRetryError>

Carries the registration’s declaration to the broker, at the same point and before the subscription opens.

fn message_bindings(&self) -> Bindings

What this subscription adds to the messages that arrive on it.