Trait DynConsumer 

pub trait DynConsumer<K, V>:
    Sealed<K, V>
    + Send
    + 'static
where
    K: Send + 'static,
    V: Send + 'static,
{
    // Required methods
    fn assignment(&mut self) -> HashSet<TopicPartition>;
    fn subscription(&mut self) -> HashSet<String>;
    fn paused(&mut self) -> HashSet<TopicPartition>;
    fn group_metadata(&mut self) -> Arc<dyn ConsumerGroupMetadata>;
    fn current_lag<'a>(
        &'a mut self,
        topic_partition: &'a TopicPartition,
    ) -> Pin<Box<dyn Future<Output = Result<Option<i64>, Error>> + Send + 'a>>;
    fn metrics(&self) -> MetricsView;
    fn subscribe_with_topics<'a>(
        &'a mut self,
        topics: Vec<String>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn subscribe_with_topics_listener<'a>(
        &'a mut self,
        topics: Vec<String>,
        listener: Arc<dyn ConsumerRebalanceListener>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn subscribe_with_pattern<'a>(
        &'a mut self,
        pattern: SubscriptionPattern,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn subscribe_with_pattern_listener<'a>(
        &'a mut self,
        pattern: SubscriptionPattern,
        listener: Arc<dyn ConsumerRebalanceListener>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn assign<'a>(
        &'a mut self,
        partitions: Vec<TopicPartition>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn unsubscribe<'a>(
        &'a mut self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn poll<'a>(
        &'a mut self,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<ConsumerRecords<K, V>, Error>> + Send + 'a>>;
    fn commit_sync<'a>(
        &'a mut self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn commit_sync_with_timeout<'a>(
        &'a mut self,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn commit_sync_with_offsets<'a>(
        &'a mut self,
        offsets: HashMap<TopicPartition, OffsetAndMetadata>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn commit_sync_with_offsets_timeout<'a>(
        &'a mut self,
        offsets: HashMap<TopicPartition, OffsetAndMetadata>,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn commit_async<'a>(
        &'a mut self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn commit_async_with_callback<'a>(
        &'a mut self,
        callback: Arc<dyn OffsetCommitCallback>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn commit_async_with_offsets_callback<'a>(
        &'a mut self,
        offsets: HashMap<TopicPartition, OffsetAndMetadata>,
        callback: Arc<dyn OffsetCommitCallback>,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn seek_with_offset<'a>(
        &'a mut self,
        partition: TopicPartition,
        offset: i64,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn seek_with_offset_and_metadata<'a>(
        &'a mut self,
        partition: TopicPartition,
        offset_and_metadata: OffsetAndMetadata,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn seek_to_beginning<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn seek_to_end<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn position<'a>(
        &'a mut self,
        partition: &'a TopicPartition,
    ) -> Pin<Box<dyn Future<Output = Result<i64, Error>> + Send + 'a>>;
    fn position_with_timeout<'a>(
        &'a mut self,
        partition: &'a TopicPartition,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<i64, Error>> + Send + 'a>>;
    fn committed<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndMetadata>>, Error>> + Send + 'a>>;
    fn committed_with_timeout<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndMetadata>>, Error>> + Send + 'a>>;
    fn partitions_for<'a>(
        &'a mut self,
        topic: &'a str,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<PartitionInfo>, Error>> + Send + 'a>>;
    fn partitions_for_with_timeout<'a>(
        &'a mut self,
        topic: &'a str,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<PartitionInfo>, Error>> + Send + 'a>>;
    fn list_topics<'a>(
        &'a mut self,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Vec<PartitionInfo>>, Error>> + Send + 'a>>;
    fn list_topics_with_timeout<'a>(
        &'a mut self,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Vec<PartitionInfo>>, Error>> + Send + 'a>>;
    fn offsets_for_times<'a>(
        &'a mut self,
        timestamps_to_search: HashMap<TopicPartition, i64>,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndTimestamp>>, Error>> + Send + 'a>>;
    fn offsets_for_times_with_timeout<'a>(
        &'a mut self,
        timestamps_to_search: HashMap<TopicPartition, i64>,
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndTimestamp>>, Error>> + Send + 'a>>;
    fn beginning_offsets<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>;
    fn beginning_offsets_with_timeout<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>;
    fn end_offsets<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>;
    fn end_offsets_with_timeout<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
        timeout: Duration,
    ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>;
    fn pause<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn resume<'a>(
        &'a mut self,
        partitions: &'a [TopicPartition],
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn enforce_rebalance<'a>(
        &'a mut self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn enforce_rebalance_with_reason<'a>(
        &'a mut self,
        reason: &'a str,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn close<'a>(
        &'a mut self,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn close_with_options<'a>(
        &'a mut self,
        options: CloseOptions,
    ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>;
    fn wakeup(&self);
    fn handle(&self) -> ConsumerHandle;
}

A dyn-compatible Consumer, for holding different consumer implementations behind one type, e.g. Box<dyn DynConsumer<K, V>>.

Every Consumer implements DynConsumer automatically, and the trait is sealed, so it cannot be implemented directly: implement Consumer instead. Each method forwards to the Consumer method of the same name; asynchronous methods return the future boxed, which costs one allocation per call. dyn DynConsumer<K, V> implements Consumer in turn, so a boxed consumer can be passed as &mut *boxed to generic code taking C: Consumer<K, V> + ?Sized, and its methods can be called with only Consumer in scope.

With both traits in scope a method call on a concrete consumer (a KafkaConsumer or MockConsumer) is ambiguous, since both apply to it; call it as Consumer::poll(&mut consumer, timeout), or import only one of the two traits. A call on a dyn DynConsumer resolves to DynConsumer’s own method either way.

use confluent_kafka::consumer::{DynConsumer, MockConsumer};

let consumers: Vec<Box<dyn DynConsumer<String, String>>> = vec![
    Box::new(MockConsumer::<String, String>::new("earliest").unwrap()),
    Box::new(MockConsumer::<String, String>::new("latest").unwrap()),
];
assert_eq!(2, consumers.len());

Required Methods

fn assignment(&mut self) -> HashSet<TopicPartition>

See Consumer::assignment.

Returns

As Consumer::assignment.

fn subscription(&mut self) -> HashSet<String>

See Consumer::subscription.

Returns

As Consumer::subscription.

fn paused(&mut self) -> HashSet<TopicPartition>

See Consumer::paused.

Returns

As Consumer::paused.

fn group_metadata(&mut self) -> Arc<dyn ConsumerGroupMetadata>

See Consumer::group_metadata.

Returns

As Consumer::group_metadata.

fn current_lag<'a>( &'a mut self, topic_partition: &'a TopicPartition, ) -> Pin<Box<dyn Future<Output = Result<Option<i64>, Error>> + Send + 'a>>

See Consumer::current_lag.

Arguments

• topic_partition - as Consumer::current_lag.

Returns

As Consumer::current_lag.

Errors

As Consumer::current_lag.

fn metrics(&self) -> MetricsView

See Consumer::metrics.

Returns

As Consumer::metrics.

fn subscribe_with_topics<'a>( &'a mut self, topics: Vec<String>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::subscribe_with_topics.

Arguments

• topics - as Consumer::subscribe_with_topics.

Errors

As Consumer::subscribe_with_topics.

fn subscribe_with_topics_listener<'a>( &'a mut self, topics: Vec<String>, listener: Arc<dyn ConsumerRebalanceListener>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::subscribe_with_topics_listener.

Arguments

• topics - as Consumer::subscribe_with_topics_listener.
• listener - as Consumer::subscribe_with_topics_listener.

Errors

As Consumer::subscribe_with_topics_listener.

fn subscribe_with_pattern<'a>( &'a mut self, pattern: SubscriptionPattern, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::subscribe_with_pattern.

Arguments

• pattern - as Consumer::subscribe_with_pattern.

Errors

As Consumer::subscribe_with_pattern.

fn subscribe_with_pattern_listener<'a>( &'a mut self, pattern: SubscriptionPattern, listener: Arc<dyn ConsumerRebalanceListener>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::subscribe_with_pattern_listener.

Arguments

• pattern - as Consumer::subscribe_with_pattern_listener.
• listener - as Consumer::subscribe_with_pattern_listener.

Errors

As Consumer::subscribe_with_pattern_listener.

fn assign<'a>( &'a mut self, partitions: Vec<TopicPartition>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::assign.

Arguments

• partitions - as Consumer::assign.

Errors

As Consumer::assign.

fn unsubscribe<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::unsubscribe.

Errors

As Consumer::unsubscribe.

fn poll<'a>( &'a mut self, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<ConsumerRecords<K, V>, Error>> + Send + 'a>>

See Consumer::poll.

Arguments

• timeout - as Consumer::poll.

Returns

As Consumer::poll.

Errors

As Consumer::poll.

fn commit_sync<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::commit_sync.

Errors

As Consumer::commit_sync.

fn commit_sync_with_timeout<'a>( &'a mut self, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::commit_sync_with_timeout.

Arguments

• timeout - as Consumer::commit_sync_with_timeout.

Errors

As Consumer::commit_sync_with_timeout.

fn commit_sync_with_offsets<'a>( &'a mut self, offsets: HashMap<TopicPartition, OffsetAndMetadata>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::commit_sync_with_offsets.

Arguments

• offsets - as Consumer::commit_sync_with_offsets.

Errors

As Consumer::commit_sync_with_offsets.

fn commit_sync_with_offsets_timeout<'a>( &'a mut self, offsets: HashMap<TopicPartition, OffsetAndMetadata>, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::commit_sync_with_offsets_timeout.

Arguments

• offsets - as Consumer::commit_sync_with_offsets_timeout.
• timeout - as Consumer::commit_sync_with_offsets_timeout.

Errors

As Consumer::commit_sync_with_offsets_timeout.

fn commit_async<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::commit_async.

Errors

As Consumer::commit_async.

fn commit_async_with_callback<'a>( &'a mut self, callback: Arc<dyn OffsetCommitCallback>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::commit_async_with_callback.

Arguments

• callback - as Consumer::commit_async_with_callback.

Errors

As Consumer::commit_async_with_callback.

fn commit_async_with_offsets_callback<'a>( &'a mut self, offsets: HashMap<TopicPartition, OffsetAndMetadata>, callback: Arc<dyn OffsetCommitCallback>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::commit_async_with_offsets_callback.

Arguments

• offsets - as Consumer::commit_async_with_offsets_callback.
• callback - as Consumer::commit_async_with_offsets_callback.

Errors

As Consumer::commit_async_with_offsets_callback.

fn seek_with_offset<'a>( &'a mut self, partition: TopicPartition, offset: i64, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::seek_with_offset.

Arguments

• partition - as Consumer::seek_with_offset.
• offset - as Consumer::seek_with_offset.

Errors

As Consumer::seek_with_offset.

fn seek_with_offset_and_metadata<'a>( &'a mut self, partition: TopicPartition, offset_and_metadata: OffsetAndMetadata, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::seek_with_offset_and_metadata.

Arguments

• partition - as Consumer::seek_with_offset_and_metadata.
• offset_and_metadata - as Consumer::seek_with_offset_and_metadata.

Errors

As Consumer::seek_with_offset_and_metadata.

fn seek_to_beginning<'a>( &'a mut self, partitions: &'a [TopicPartition], ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::seek_to_beginning.

Arguments

• partitions - as Consumer::seek_to_beginning.

Errors

As Consumer::seek_to_beginning.

fn seek_to_end<'a>( &'a mut self, partitions: &'a [TopicPartition], ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::seek_to_end.

Arguments

• partitions - as Consumer::seek_to_end.

Errors

As Consumer::seek_to_end.

fn position<'a>( &'a mut self, partition: &'a TopicPartition, ) -> Pin<Box<dyn Future<Output = Result<i64, Error>> + Send + 'a>>

See Consumer::position.

Arguments

• partition - as Consumer::position.

Returns

As Consumer::position.

Errors

As Consumer::position.

fn position_with_timeout<'a>( &'a mut self, partition: &'a TopicPartition, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<i64, Error>> + Send + 'a>>

See Consumer::position_with_timeout.

Arguments

• partition - as Consumer::position_with_timeout.
• timeout - as Consumer::position_with_timeout.

Returns

As Consumer::position_with_timeout.

Errors

As Consumer::position_with_timeout.

fn committed<'a>( &'a mut self, partitions: &'a [TopicPartition], ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndMetadata>>, Error>> + Send + 'a>>

See Consumer::committed.

Arguments

• partitions - as Consumer::committed.

Returns

As Consumer::committed.

Errors

As Consumer::committed.

fn committed_with_timeout<'a>( &'a mut self, partitions: &'a [TopicPartition], timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndMetadata>>, Error>> + Send + 'a>>

See Consumer::committed_with_timeout.

Arguments

• partitions - as Consumer::committed_with_timeout.
• timeout - as Consumer::committed_with_timeout.

Returns

As Consumer::committed_with_timeout.

Errors

As Consumer::committed_with_timeout.

fn partitions_for<'a>( &'a mut self, topic: &'a str, ) -> Pin<Box<dyn Future<Output = Result<Vec<PartitionInfo>, Error>> + Send + 'a>>

See Consumer::partitions_for.

Arguments

• topic - as Consumer::partitions_for.

Returns

As Consumer::partitions_for.

Errors

As Consumer::partitions_for.

fn partitions_for_with_timeout<'a>( &'a mut self, topic: &'a str, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<Vec<PartitionInfo>, Error>> + Send + 'a>>

See Consumer::partitions_for_with_timeout.

Arguments

• topic - as Consumer::partitions_for_with_timeout.
• timeout - as Consumer::partitions_for_with_timeout.

Returns

As Consumer::partitions_for_with_timeout.

Errors

As Consumer::partitions_for_with_timeout.

fn list_topics<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Vec<PartitionInfo>>, Error>> + Send + 'a>>

See Consumer::list_topics.

Returns

As Consumer::list_topics.

Errors

As Consumer::list_topics.

fn list_topics_with_timeout<'a>( &'a mut self, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Vec<PartitionInfo>>, Error>> + Send + 'a>>

See Consumer::list_topics_with_timeout.

Arguments

• timeout - as Consumer::list_topics_with_timeout.

Returns

As Consumer::list_topics_with_timeout.

Errors

As Consumer::list_topics_with_timeout.

fn offsets_for_times<'a>( &'a mut self, timestamps_to_search: HashMap<TopicPartition, i64>, ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndTimestamp>>, Error>> + Send + 'a>>

See Consumer::offsets_for_times.

Arguments

• timestamps_to_search - as Consumer::offsets_for_times.

Returns

As Consumer::offsets_for_times.

Errors

As Consumer::offsets_for_times.

fn offsets_for_times_with_timeout<'a>( &'a mut self, timestamps_to_search: HashMap<TopicPartition, i64>, timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndTimestamp>>, Error>> + Send + 'a>>

See Consumer::offsets_for_times_with_timeout.

Arguments

• timestamps_to_search - as Consumer::offsets_for_times_with_timeout.
• timeout - as Consumer::offsets_for_times_with_timeout.

Returns

As Consumer::offsets_for_times_with_timeout.

Errors

As Consumer::offsets_for_times_with_timeout.

fn beginning_offsets<'a>( &'a mut self, partitions: &'a [TopicPartition], ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>

See Consumer::beginning_offsets.

Arguments

• partitions - as Consumer::beginning_offsets.

Returns

As Consumer::beginning_offsets.

Errors

As Consumer::beginning_offsets.

fn beginning_offsets_with_timeout<'a>( &'a mut self, partitions: &'a [TopicPartition], timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>

See Consumer::beginning_offsets_with_timeout.

Arguments

• partitions - as Consumer::beginning_offsets_with_timeout.
• timeout - as Consumer::beginning_offsets_with_timeout.

Returns

As Consumer::beginning_offsets_with_timeout.

Errors

As Consumer::beginning_offsets_with_timeout.

fn end_offsets<'a>( &'a mut self, partitions: &'a [TopicPartition], ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>

See Consumer::end_offsets.

Arguments

• partitions - as Consumer::end_offsets.

Returns

As Consumer::end_offsets.

Errors

As Consumer::end_offsets.

fn end_offsets_with_timeout<'a>( &'a mut self, partitions: &'a [TopicPartition], timeout: Duration, ) -> Pin<Box<dyn Future<Output = Result<HashMap<TopicPartition, i64>, Error>> + Send + 'a>>

See Consumer::end_offsets_with_timeout.

Arguments

• partitions - as Consumer::end_offsets_with_timeout.
• timeout - as Consumer::end_offsets_with_timeout.

Returns

As Consumer::end_offsets_with_timeout.

Errors

As Consumer::end_offsets_with_timeout.

fn pause<'a>( &'a mut self, partitions: &'a [TopicPartition], ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::pause.

Arguments

• partitions - as Consumer::pause.

Errors

As Consumer::pause.

fn resume<'a>( &'a mut self, partitions: &'a [TopicPartition], ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::resume.

Arguments

• partitions - as Consumer::resume.

Errors

As Consumer::resume.

fn enforce_rebalance<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::enforce_rebalance.

Errors

As Consumer::enforce_rebalance.

fn enforce_rebalance_with_reason<'a>( &'a mut self, reason: &'a str, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::enforce_rebalance_with_reason.

Arguments

• reason - as Consumer::enforce_rebalance_with_reason.

Errors

As Consumer::enforce_rebalance_with_reason.

fn close<'a>( &'a mut self, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::close.

Errors

As Consumer::close.

fn close_with_options<'a>( &'a mut self, options: CloseOptions, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'a>>

See Consumer::close_with_options.

Arguments

• options - as Consumer::close_with_options.

Errors

As Consumer::close_with_options.

fn wakeup(&self)

See Consumer::wakeup.

fn handle(&self) -> ConsumerHandle

See Consumer::handle.

Returns

As Consumer::handle.

Trait Implementations

impl<K, V> Consumer<K, V> for dyn DynConsumer<K, V>

where K: Send + 'static, V: Send + 'static,

fn assignment(&mut self) -> HashSet<TopicPartition>

Get the set of partitions currently assigned to this consumer. If subscription happened by directly assigning partitions using Self::assign then this will simply return the same partitions that were assigned. If topic subscription was used, then this will give the set of topic partitions currently assigned to the consumer (which may be none if the assignment hasn’t happened yet, or the partitions are in the process of getting reassigned).

fn subscription(&mut self) -> HashSet<String>

Get the current subscription. Will return the same topics used in the most recent call to Self::subscribe_with_topics or Self::subscribe_with_topics_listener, or an empty set if no such call has been made.

fn paused(&mut self) -> HashSet<TopicPartition>

Get the set of partitions that were previously paused by a call to Self::pause.

fn group_metadata(&mut self) -> Arc<dyn ConsumerGroupMetadata>

Return the current group metadata associated with this consumer.

async fn current_lag( &mut self, topic_partition: &TopicPartition, ) -> Result<Option<i64>, Error>

Get the consumer’s current lag on the partition. Returns None if the lag is not known, for example if there is no position yet, or if the end offset is not known yet.

fn metrics(&self) -> MetricsView

Get the metrics kept by the consumer

fn subscribe_with_topics( &mut self, topics: Vec<String>, ) -> impl Future<Output = Result<(), Error>> + Send

Subscribe to the given list of topics to get dynamically assigned partitions. Topic subscriptions are not incremental. This list will replace the current assignment (if there is one). It is not possible to combine topic subscription with group management with manual partition assignment through Self::assign. If the given list of topics is empty, it is treated the same as Self::unsubscribe.

fn subscribe_with_topics_listener( &mut self, topics: Vec<String>, listener: Arc<dyn ConsumerRebalanceListener>, ) -> impl Future<Output = Result<(), Error>> + Send

Subscribe to the given list of topics to get dynamically assigned partitions. Topic subscriptions are not incremental. This list will replace the current assignment (if there is one). Note that it is not possible to combine topic subscription with group management with manual partition assignment through Self::assign. If the given list of topics is empty, it is treated the same as Self::unsubscribe.

fn subscribe_with_pattern( &mut self, pattern: SubscriptionPattern, ) -> impl Future<Output = Result<(), Error>> + Send

Subscribe to all topics matching the specified pattern, to get dynamically assigned partitions. The pattern matching will be done periodically against topics. This is only supported under the CONSUMER group protocol (see ConsumerConfig::GROUP_PROTOCOL_CONFIG)

fn subscribe_with_pattern_listener( &mut self, pattern: SubscriptionPattern, listener: Arc<dyn ConsumerRebalanceListener>, ) -> impl Future<Output = Result<(), Error>> + Send

Subscribe to all topics matching the specified pattern, to get dynamically assigned partitions. The pattern matching will be done periodically against all topics. This is only supported under the CONSUMER group protocol (see ConsumerConfig::GROUP_PROTOCOL_CONFIG).

fn assign( &mut self, partitions: Vec<TopicPartition>, ) -> impl Future<Output = Result<(), Error>> + Send

Manually assign a list of partitions to this consumer. This interface does not allow for incremental assignment and will replace the previous assignment (if there is one).

fn unsubscribe(&mut self) -> impl Future<Output = Result<(), Error>> + Send

Unsubscribe from topics currently subscribed with Self::subscribe_with_topics or Self::subscribe_with_pattern. This also clears any partitions directly assigned through Self::assign.

fn poll( &mut self, timeout: Duration, ) -> impl Future<Output = Result<ConsumerRecords<K, V>, Error>> + Send

Fetch data for the topics or partitions specified using one of the subscribe/assign APIs. It is an error to not have subscribed to any topics or partitions before polling for data.

fn commit_sync(&mut self) -> impl Future<Output = Result<(), Error>> + Send

Commit offsets returned on the last poll() for all the subscribed list of topics and partitions.

fn commit_sync_with_timeout( &mut self, timeout: Duration, ) -> impl Future<Output = Result<(), Error>> + Send

Commit offsets returned on the last poll() for all the subscribed list of topics and partitions.

fn commit_sync_with_offsets( &mut self, offsets: HashMap<TopicPartition, OffsetAndMetadata>, ) -> impl Future<Output = Result<(), Error>> + Send

Commit the specified offsets for the specified list of topics and partitions.

fn commit_sync_with_offsets_timeout( &mut self, offsets: HashMap<TopicPartition, OffsetAndMetadata>, timeout: Duration, ) -> impl Future<Output = Result<(), Error>> + Send

Commit the specified offsets for the specified list of topics and partitions.

fn commit_async(&mut self) -> impl Future<Output = Result<(), Error>> + Send

Commit offsets returned on the last Self::poll for all the subscribed list of topics and partition. Same as commitAsync(None)

fn commit_async_with_callback( &mut self, callback: Arc<dyn OffsetCommitCallback>, ) -> impl Future<Output = Result<(), Error>> + Send

Commit offsets returned on the last poll() for the subscribed list of topics and partitions.

fn commit_async_with_offsets_callback( &mut self, offsets: HashMap<TopicPartition, OffsetAndMetadata>, callback: Arc<dyn OffsetCommitCallback>, ) -> impl Future<Output = Result<(), Error>> + Send

Commit the specified offsets for the specified list of topics and partitions to Kafka.

fn seek_with_offset( &mut self, partition: TopicPartition, offset: i64, ) -> impl Future<Output = Result<(), Error>> + Send

Overrides the fetch offsets that the consumer will use on the next poll(timeout). If this API is invoked for the same partition more than once, the latest offset will be used on the next poll(). Note that you may lose data if this API is arbitrarily used in the middle of consumption, to reset the fetch offsets

fn seek_with_offset_and_metadata( &mut self, partition: TopicPartition, offset_and_metadata: OffsetAndMetadata, ) -> impl Future<Output = Result<(), Error>> + Send

Overrides the fetch offsets that the consumer will use on the next poll(timeout). If this API is invoked for the same partition more than once, the latest offset will be used on the next poll(). Note that you may lose data if this API is arbitrarily used in the middle of consumption, to reset the fetch offsets. This method allows for setting the leaderEpoch along with the desired offset.

async fn seek_to_beginning( &mut self, partitions: &[TopicPartition], ) -> Result<(), Error>

Seek to the first offset for each of the given partitions. This function evaluates lazily, seeking to the first offset in all partitions only when Self::poll or Self::position are called. If no partitions are provided, seek to the first offset for all of the currently assigned partitions.

async fn seek_to_end( &mut self, partitions: &[TopicPartition], ) -> Result<(), Error>

Seek to the last offset for each of the given partitions. This function evaluates lazily, seeking to the final offset in all partitions only when Self::poll or Self::position are called. If no partitions are provided, seek to the final offset for all of the currently assigned partitions.

async fn position(&mut self, partition: &TopicPartition) -> Result<i64, Error>

Get the offset of the next record that will be fetched (if a record with that offset exists). This method may issue a remote call to the server if there is no current position for the given partition.

async fn position_with_timeout( &mut self, partition: &TopicPartition, timeout: Duration, ) -> Result<i64, Error>

Get the offset of the next record that will be fetched (if a record with that offset exists). This method may issue a remote call to the server if there is no current position for the given partition.

async fn committed( &mut self, partitions: &[TopicPartition], ) -> Result<HashMap<TopicPartition, Option<OffsetAndMetadata>>, Error>

Get the last committed offsets for the given partitions (whether the commit happened by this process or another). The returned offsets will be used as the position for the consumer in the event of a failure.

async fn committed_with_timeout( &mut self, partitions: &[TopicPartition], timeout: Duration, ) -> Result<HashMap<TopicPartition, Option<OffsetAndMetadata>>, Error>

Get the last committed offsets for the given partitions (whether the commit happened by this process or another). The returned offsets will be used as the position for the consumer in the event of a failure.

async fn partitions_for( &mut self, topic: &str, ) -> Result<Vec<PartitionInfo>, Error>

Get metadata about the partitions for a given topic. This method will issue a remote call to the server if it does not already have any metadata about the given topic.

async fn partitions_for_with_timeout( &mut self, topic: &str, timeout: Duration, ) -> Result<Vec<PartitionInfo>, Error>

Get metadata about the partitions for a given topic. This method will issue a remote call to the server if it does not already have any metadata about the given topic.

fn list_topics( &mut self, ) -> impl Future<Output = Result<HashMap<String, Vec<PartitionInfo>>, Error>> + Send

Get metadata about partitions for all topics that the user is authorized to view. This method will issue a remote call to the server.

fn list_topics_with_timeout( &mut self, timeout: Duration, ) -> impl Future<Output = Result<HashMap<String, Vec<PartitionInfo>>, Error>> + Send

Get metadata about partitions for all topics that the user is authorized to view. This method will issue a remote call to the server.

fn offsets_for_times( &mut self, timestamps_to_search: HashMap<TopicPartition, i64>, ) -> impl Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndTimestamp>>, Error>> + Send

Look up the offsets for the given partitions by timestamp. The returned offset for each partition is the earliest offset whose timestamp is greater than or equal to the given timestamp in the corresponding partition. This is a blocking call. The consumer does not have to be assigned the partitions. If the message format version in a partition is before 0.10.0, i.e. the messages do not have timestamps, None will be returned for that partition.

fn offsets_for_times_with_timeout( &mut self, timestamps_to_search: HashMap<TopicPartition, i64>, timeout: Duration, ) -> impl Future<Output = Result<HashMap<TopicPartition, Option<OffsetAndTimestamp>>, Error>> + Send

Look up the offsets for the given partitions by timestamp. The returned offset for each partition is the earliest offset whose timestamp is greater than or equal to the given timestamp in the corresponding partition. This is a blocking call. The consumer does not have to be assigned the partitions. If the message format version in a partition is before 0.10.0, i.e. the messages do not have timestamps, None will be returned for that partition.

async fn beginning_offsets( &mut self, partitions: &[TopicPartition], ) -> Result<HashMap<TopicPartition, i64>, Error>

Get the first offset for the given partitions.

async fn beginning_offsets_with_timeout( &mut self, partitions: &[TopicPartition], timeout: Duration, ) -> Result<HashMap<TopicPartition, i64>, Error>

Get the first offset for the given partitions.

async fn end_offsets( &mut self, partitions: &[TopicPartition], ) -> Result<HashMap<TopicPartition, i64>, Error>

Get the end offsets for the given partitions. In the default read_uncommitted isolation level, the end offset is the high watermark (that is, the offset of the last successfully replicated message plus one). For read_committed consumers, the end offset is the last stable offset (LSO), which is the minimum of the high watermark and the smallest offset of any open transaction. Finally, if the partition has never been written to, the end offset is 0.

async fn end_offsets_with_timeout( &mut self, partitions: &[TopicPartition], timeout: Duration, ) -> Result<HashMap<TopicPartition, i64>, Error>

Get the end offsets for the given partitions. In the default read_uncommitted isolation level, the end offset is the high watermark (that is, the offset of the last successfully replicated message plus one). For read_committed consumers, the end offset is the last stable offset (LSO), which is the minimum of the high watermark and the smallest offset of any open transaction. Finally, if the partition has never been written to, the end offset is 0.

async fn pause(&mut self, partitions: &[TopicPartition]) -> Result<(), Error>

Suspend fetching from the requested partitions. Future calls to Self::poll will not return any records from these partitions until they have been resumed using Self::resume. Note that this method does not affect partition subscription. In particular, it does not cause a group rebalance when automatic assignment is used.

async fn resume(&mut self, partitions: &[TopicPartition]) -> Result<(), Error>

Resume specified partitions which have been paused with Self::pause. New calls to Self::poll will return records from these partitions if there are any to be fetched. If the partitions were not previously paused, this method is a no-op.

fn enforce_rebalance( &mut self, ) -> impl Future<Output = Result<(), Error>> + Send

Alert the consumer to trigger a new rebalance by rejoining the group. This is a nonblocking call that forces the consumer to trigger a new rebalance on the next Self::poll call. Note that this API does not itself initiate the rebalance, so you must still call Self::poll. If a rebalance is already in progress this call will be a no-op. If you wish to force an additional rebalance you must complete the current one by calling poll before retrying this API.

async fn enforce_rebalance_with_reason( &mut self, reason: &str, ) -> Result<(), Error>

Alert the consumer to trigger a new rebalance by rejoining the group. This is a nonblocking call that forces the consumer to trigger a new rebalance on the next Self::poll call. Note that this API does not itself initiate the rebalance, so you must still call Self::poll. If a rebalance is already in progress this call will be a no-op. If you wish to force an additional rebalance you must complete the current one by calling poll before retrying this API.

fn close(&mut self) -> impl Future<Output = Result<(), Error>> + Send

Close the consumer with default leave group behavior, waiting for up to the default timeout of 30 seconds for any needed cleanup. If auto-commit is enabled, this will commit the current offsets if possible within the default timeout. See Self::close for details. Note that Self::wakeup cannot be used to interrupt close.

fn close_with_options( &mut self, options: CloseOptions, ) -> impl Future<Output = Result<(), Error>> + Send

Close the consumer cleanly. CloseOptions allows to specify a timeout and a leave group behavior. If no timeout is specified, the default timeout of 30 seconds is used. If no leave group behavior is specified, the default leave group behavior is used.

fn wakeup(&self)

Wakeup the consumer. This method is thread-safe and is useful in particular to abort a long poll. The thread which is blocking in an operation will throw WakeupError. If no thread is blocking in a method which can throw WakeupError, the next call to such a method will raise it instead.

fn handle(&self) -> ConsumerHandle

Returns a Clone + Send + Sync ConsumerHandle exposing Consumer::wakeup and the reentrant-safe consumer operations, callable from a task / thread other than the one that owns the consumer.

Implementors

impl<K, V, C> DynConsumer<K, V> for C

where K: Send + 'static, V: Send + 'static, C: Consumer<K, V>,